le_smsInbox1_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_smsInbox SMS Inbox
14  *
15  * @ref le_smsInbox1_interface.h "API Reference"
16  *
17  * <HR>
18  *
19  * 3rd-party customer applications need to access to SMS messages at anytime without worrying how
20  * the resources are managed.
21  *
22  * Legato provides an SMS Inbox service to allow apps to receive SMS messages through their own,
23  * private message box, without:
24  * - having to manage SIM or modem memory;
25  * - conflicting with other applications that also receive SMS messages;
26  * - missing messages while being updated or restarted.
27  *
28  *
29  * The SMS Inbox Service handles the resource arbitration for the user app: the message
30  * reception is always guaranteed, for example the user app doesn't have to worried about freeing
31  * space in the SIM (or device's storage area) when it is full.
32  *
33  * In fact, at device's startup or when a SIM is inserted, the SIM content is copied into the "Inbox
34  * Message Storage" folder allocated in the root file system of the device. Then, the process frees
35  * automatically the SIM content.
36  * Moreover, every new received SMS message is automatically copied into the "Inbox
37  * Message Storage" folder and deleted from the SIM.
38  * This mechanism keeps the SIM always empty in order to guarantee the reception of SMS messages.
39  *
40  * This process is the same when the SMS message storage is the device's storage area (ME - Mobile
41  * Equipment).
42  *
43  * The message box is a persistent storage area. All files are saved into the file system in the
44  * directory /mnt/flash/smsInbox.
45  *
46  * The creation of SMS inboxes is done based on the message box configuration settings
47  * (cf. @subpage le_smsInbox_configdb section). This way, the message box contents will be kept up
48  * to date automatically by the SMS Inbox Service, even when the user app is slow to start, is
49  * stopped while it is being updated, or is being restarted to recover from a fault.
50  *
51  * A message box works as a circular buffer, when the message box is filled, the older messages
52  * are deleted to free space for new messages. But, the application can also explicitly delete
53  * messages if it doesn't need them anymore.
54  *
55  * @section le_smsInbox_binding IPC interfaces binding
56  *
57  * All the functions of this API are provided by the @b smsInboxService application service.
58  *
59  * Here's a code sample binding to SMS Inbox services:
60  * @verbatim
61  bindings:
62  {
63  clientExe.clientComponent.le_smsInbox1 -> smsInboxService.le_smsInbox1
64  }
65  @endverbatim
66  *
67  * @note By default, smsInboxService starts manually. To start it automatically, the user can remove
68  * the option from the smsInboxService.adef file.
69  *
70  * A second message box (named le_smsInbox2) can be used by another application. These 2 message
71  * boxes are used independently. All functions of this second message box are prefixed by
72  * le_smsInbox2 (instead of le_msmInbox1).
73  * The user can implement other message boxes based on le_smsInbox1 and le_smsInbox2 model.
74  *
75  * @section le_smsInbox_init Initialise a message box
76  * Use the API le_smsInbox1_Open() to open a message box for access.
77  *
78  * @section le_smsInbox_receiving Receiving a message
79  * To receive messages, register a handler function to obtain incoming
80  * messages. Use le_smsInbox1_AddRxMessageHandler() to register that handler.
81  *
82  * The handler must satisfy the following prototype:
83  * @code
84  * typedef void (*le_smsInbox1_RxMessageHandlerFunc_t)
85  * (
86  * uint32_t msgId,
87  * void* contextPtr
88  * )
89  * @endcode
90  *
91  * If a succession of messages is received, a new Message reference is created for each, and
92  * the handler is called for each new message.
93  *
94  * Uninstall the handler function by calling le_smsInbox1_RemoveRxMessageHandler().
95  *
96  * @note le_smsInbox1_RemoveRxMessageHandler() function does not delete the Message Object.
97  * The caller has to delete it with le_smsInbox1_DeleteMsg().
98  *
99  * Use the following APIs to retrieve message information and data from the message object:
100  * - le_smsInbox1_GetImsi() - get the IMSI of the message receiver SIM if it applies.
101  * - le_smsInbox1_GetFormat() - determine if it is a binary or a text message.
102  * - le_smsInbox1_GetSenderTel() - get the sender's Telephone number.
103  * - le_smsInbox1_GetTimeStamp() - get the timestamp sets by the Service Center.
104  * - le_smsInbox1_GetMsgLen() - get the message content length.
105  * - le_smsInbox1_GetText() - get the message text.
106  * - le_smsInbox1_GetBinary() - get the message binary content.
107  * - le_smsInbox1_GetPdu() - get the PDU message content.
108  *
109  * @note For incoming SMS Inbox, format returned by le_smsInbox1_GetFormat() is never
110  * LE_SMSINBOX1_FORMAT_PDU.
111  *
112  * @section le_smsInbox_listing Getting received messages
113  *
114  * Call le_smsInbox1_GetFirst() to get the first message from the inbox folder, and then call
115  * le_smsInbox1_GetNext() to get the next message.
116  *
117  * Call le_smsInbox1_IsUnread() to know whether the message has been read or not. The message is
118  * marked as "read" when one of those APIs is called: le_smsInbox1_GetImsi(),
119  * le_smsInbox1_GetFormat(), le_smsInbox1_GetSenderTel(), le_smsInbox1_GetTimeStamp(),
120  * le_smsInbox1_GetMsgLen(), le_smsInbox1_GetText(), le_smsInbox1_GetBinary(), le_smsInbox1_GetPdu().
121  *
122  * To finish, you can also modify the received status of a message with le_smsInbox1_MarkRead() and
123  * le_smsInbox1_MarkUnread().
124  *
125  * @note The message status is tied to the client app.
126  *
127  * @section le_smsInbox1_deleting Deleting a message
128  *
129  * le_smsInbox1_DeleteMsg() deletes the message from the folder. Message is identified with
130  * le_smsInbox1_MsgRef_t object. The function returns an error if the message is not found.
131  *
132  * @section le_smsInbox_end Close a message box
133  * Use the API le_smsInbox1_Close() to close a message box (the message box is still exist and can be
134  * re-opened and retrieve later all the messages).
135  *
136  * @section le_smsInbox_configdb Configuration tree
137  *
138  * @section le_smsInbox_MaxMessage() Messagebox Database Configuration
139  *
140  * Use le_smsInbox1_SetMaxMessages() to set the maximum number of messages for message box.
141  * Use le_smsInbox1_GetMaxMessages() to get the maximum number of messages for message box.
142  *
143  * @copydoc le_smsInbox_configdbPage_Hide
144  *
145  * <HR>
146  *
147  * Copyright (C) Sierra Wireless Inc.
148  */
149 /**
150  * @interface le_smsInbox_configdbPage_Hide
151  *
152  * The configuration database for the SMS Inbox Service is stored in the @c smsInboxService config
153  * tree:
154  * @verbatim
155  smsInboxService:/
156  smsInbox/
157  apps/
158  appA<uint> = <# of messages>
159  appB<uint> = <# of messages>
160  @endverbatim
161  *
162  * Each app have its own inbox, containing its own list of messages. The maximum number of
163  * messages is specified for each inbox. If the message box is not configured, a default number
164  * of 10 messages is applied (only for message boxes configured in le_smsInbox_mboxName[]
165  * area).
166  *
167  * The application name is given by the API name provided into the Components.cdef, both must be the
168  * same.
169  *
170  * @todo: Give an indication of memory consumption for 1 message, including the file system overhead
171  * (inode, directory entry, etc...).
172  *
173  *
174  */
175 /**
176  * @file le_smsInbox1_interface.h
177  *
178  * Legato @ref c_smsInbox include file.
179  *
180  * Copyright (C) Sierra Wireless Inc.
181  */
182 
183 #ifndef LE_SMSINBOX1_INTERFACE_H_INCLUDE_GUARD
184 #define LE_SMSINBOX1_INTERFACE_H_INCLUDE_GUARD
185 
186 
187 #include "legato.h"
188 
189 // Interface specific includes
190 #include "le_mdmDefs_interface.h"
191 #include "le_sim_interface.h"
192 #include "le_sms_interface.h"
193 
194 
195 //--------------------------------------------------------------------------------------------------
196 /**
197  * Type for handler called when a server disconnects.
198  */
199 //--------------------------------------------------------------------------------------------------
200 typedef void (*le_smsInbox1_DisconnectHandler_t)(void *);
201 
202 //--------------------------------------------------------------------------------------------------
203 /**
204  *
205  * Connect the current client thread to the service providing this API. Block until the service is
206  * available.
207  *
208  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
209  * called before any other functions in this API. Normally, ConnectService is automatically called
210  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
211  *
212  * This function is created automatically.
213  */
214 //--------------------------------------------------------------------------------------------------
216 (
217  void
218 );
219 
220 //--------------------------------------------------------------------------------------------------
221 /**
222  *
223  * Try to connect the current client thread to the service providing this API. Return with an error
224  * if the service is not available.
225  *
226  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
227  * called before any other functions in this API. Normally, ConnectService is automatically called
228  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
229  *
230  * This function is created automatically.
231  *
232  * @return
233  * - LE_OK if the client connected successfully to the service.
234  * - LE_UNAVAILABLE if the server is not currently offering the service to which the client is
235  * bound.
236  * - LE_NOT_PERMITTED if the client interface is not bound to any service (doesn't have a binding).
237  * - LE_COMM_ERROR if the Service Directory cannot be reached.
238  */
239 //--------------------------------------------------------------------------------------------------
241 (
242  void
243 );
244 
245 //--------------------------------------------------------------------------------------------------
246 /**
247  * Set handler called when server disconnection is detected.
248  *
249  * When a server connection is lost, call this handler then exit with LE_FATAL. If a program wants
250  * to continue without exiting, it should call longjmp() from inside the handler.
251  */
252 //--------------------------------------------------------------------------------------------------
254 (
255  le_smsInbox1_DisconnectHandler_t disconnectHandler,
256  void *contextPtr
257 );
258 
259 //--------------------------------------------------------------------------------------------------
260 /**
261  *
262  * Disconnect the current client thread from the service providing this API.
263  *
264  * Normally, this function doesn't need to be called. After this function is called, there's no
265  * longer a connection to the service, and the functions in this API can't be used. For details, see
266  * @ref apiFilesC_client.
267  *
268  * This function is created automatically.
269  */
270 //--------------------------------------------------------------------------------------------------
272 (
273  void
274 );
275 
276 
277 //--------------------------------------------------------------------------------------------------
278 /**
279  * Define unknown format
280  */
281 //--------------------------------------------------------------------------------------------------
282 #define LE_SMSINBOX1_FORMAT_UNKNOWN -1
283 
284 //--------------------------------------------------------------------------------------------------
285 /**
286  * Define the name of length of the message box name
287  */
288 //--------------------------------------------------------------------------------------------------
289 #define LE_SMSINBOX1_MAX_MBOX_NAME_LEN 12
290 
291 //--------------------------------------------------------------------------------------------------
292 /**
293  * Reference type for referring to open message box sessions.
294  */
295 //--------------------------------------------------------------------------------------------------
296 typedef struct le_smsInbox1_Session* le_smsInbox1_SessionRef_t;
297 
298 
299 //--------------------------------------------------------------------------------------------------
300 /**
301  * Reference type used by Add/Remove functions for EVENT 'le_smsInbox1_RxMessage'
302  */
303 //--------------------------------------------------------------------------------------------------
304 typedef struct le_smsInbox1_RxMessageHandler* le_smsInbox1_RxMessageHandlerRef_t;
305 
306 
307 //--------------------------------------------------------------------------------------------------
308 /**
309  * Handler for New Message.
310  *
311  */
312 //--------------------------------------------------------------------------------------------------
314 (
315  uint32_t msgId,
316  ///< Message identifier.
317  void* contextPtr
318  ///<
319 );
320 
321 //--------------------------------------------------------------------------------------------------
322 /**
323  * Open a message box.
324  *
325  * @return
326  * Reference on the opened message box session
327  */
328 //--------------------------------------------------------------------------------------------------
330 (
331  void
332 );
333 
334 //--------------------------------------------------------------------------------------------------
335 /**
336  * Close a previously open message box.
337  *
338  */
339 //--------------------------------------------------------------------------------------------------
341 (
342  le_smsInbox1_SessionRef_t sessionRef
343  ///< [IN] Mailbox session reference.
344 );
345 
346 //--------------------------------------------------------------------------------------------------
347 /**
348  * Add handler function for EVENT 'le_smsInbox1_RxMessage'
349  *
350  * This event provides information on new received messages.
351  *
352  */
353 //--------------------------------------------------------------------------------------------------
355 (
357  ///< [IN]
358  void* contextPtr
359  ///< [IN]
360 );
361 
362 //--------------------------------------------------------------------------------------------------
363 /**
364  * Remove handler function for EVENT 'le_smsInbox1_RxMessage'
365  */
366 //--------------------------------------------------------------------------------------------------
368 (
370  ///< [IN]
371 );
372 
373 //--------------------------------------------------------------------------------------------------
374 /**
375  * Delete a Message.
376  *
377  * @note It is valid to delete a non-existent message.
378  */
379 //--------------------------------------------------------------------------------------------------
381 (
382  uint32_t msgId
383  ///< [IN] Message identifier.
384 );
385 
386 //--------------------------------------------------------------------------------------------------
387 /**
388  * Retrieves the IMSI of the message receiver SIM if it applies.
389  *
390  * @return
391  * - LE_NOT_FOUND The message item is not tied to a SIM card, the imsi string is empty.
392  * - LE_OVERFLOW The imsiPtr buffer was too small for the IMSI.
393  * - LE_BAD_PARAMETER The message reference is invalid.
394  * - LE_FAULT The function failed.
395  * - LE_OK The function succeeded.
396  *
397  */
398 //--------------------------------------------------------------------------------------------------
400 (
401  uint32_t msgId,
402  ///< [IN] Message identifier.
403  char* imsi,
404  ///< [OUT] IMSI.
405  size_t imsiSize
406  ///< [IN]
407 );
408 
409 //--------------------------------------------------------------------------------------------------
410 /**
411  * Get the message format (text, binary or PDU).
412  *
413  * @return
414  * - Message format.
415  * - FORMAT_UNKNOWN when the message format cannot be identified or the message reference is
416  * invalid.
417  * @note For incoming SMS Inbox, format returned by le_smsInbox1_GetFormat() is never
418  * LE_SMSINBOX1_FORMAT_PDU.
419  */
420 //--------------------------------------------------------------------------------------------------
422 (
423  uint32_t msgId
424  ///< [IN] Message identifier.
425 );
426 
427 //--------------------------------------------------------------------------------------------------
428 /**
429  * Get the Sender Identifier.
430  *
431  * @return
432  * - LE_BAD_PARAMETER The message reference is invalid.
433  * - LE_OVERFLOW Identifier length exceed the maximum length.
434  * - LE_OK Function succeeded.
435  */
436 //--------------------------------------------------------------------------------------------------
438 (
439  uint32_t msgId,
440  ///< [IN] Message identifier.
441  char* tel,
442  ///< [OUT] Identifier string.
443  size_t telSize
444  ///< [IN]
445 );
446 
447 //--------------------------------------------------------------------------------------------------
448 /**
449  * Get the Message Time Stamp string (it does not apply for PDU message).
450  *
451  * @return
452  * - LE_BAD_PARAMETER The message reference is invalid.
453  * - LE_NOT_FOUND The message is a PDU message.
454  * - LE_OVERFLOW Timestamp number length exceed the maximum length.
455  * - LE_OK Function succeeded.
456  */
457 //--------------------------------------------------------------------------------------------------
459 (
460  uint32_t msgId,
461  ///< [IN] Message identifier.
462  char* timestamp,
463  ///< [OUT] Message time stamp (for text or binary
464  ///< messages). String format:
465  ///< "yy/MM/dd,hh:mm:ss+/-zz"
466  ///< (Year/Month/Day,Hour:Min:Seconds+/-TimeZone)
467  size_t timestampSize
468  ///< [IN]
469 );
470 
471 //--------------------------------------------------------------------------------------------------
472 /**
473  * Get the message Length value.
474  *
475  * @return Number of characters for text messages, or the length of the data in bytes for raw
476  * binary and PDU messages.
477  */
478 //--------------------------------------------------------------------------------------------------
480 (
481  uint32_t msgId
482  ///< [IN] Message identifier.
483 );
484 
485 //--------------------------------------------------------------------------------------------------
486 /**
487  * Get the text Message.
488  *
489  *
490  * @return
491  * - LE_BAD_PARAMETER The message reference is invalid.
492  * - LE_FORMAT_ERROR Message is not in text format.
493  * - LE_OVERFLOW Message length exceed the maximum length.
494  * - LE_OK Function succeeded.
495  */
496 //--------------------------------------------------------------------------------------------------
498 (
499  uint32_t msgId,
500  ///< [IN] Message identifier.
501  char* text,
502  ///< [OUT] Message text.
503  size_t textSize
504  ///< [IN]
505 );
506 
507 //--------------------------------------------------------------------------------------------------
508 /**
509  * Get the binary Message.
510  *
511  *
512  * @return
513  * - LE_BAD_PARAMETER The message reference is invalid.
514  * - LE_FORMAT_ERROR Message is not in binary format.
515  * - LE_OVERFLOW Message length exceed the maximum length.
516  * - LE_OK Function succeeded.
517  */
518 //--------------------------------------------------------------------------------------------------
520 (
521  uint32_t msgId,
522  ///< [IN] Message identifier.
523  uint8_t* binPtr,
524  ///< [OUT] Binary message.
525  size_t* binSizePtr
526  ///< [INOUT]
527 );
528 
529 //--------------------------------------------------------------------------------------------------
530 /**
531  * Get the PDU message.
532  *
533  * Output parameters are updated with the PDU message content and the length of the PDU message
534  * in bytes.
535  *
536  * @return
537  * - LE_BAD_PARAMETER The message reference is invalid.
538  * - LE_FORMAT_ERROR Unable to encode the message in PDU.
539  * - LE_OVERFLOW Message length exceed the maximum length.
540  * - LE_OK Function succeeded.
541  */
542 //--------------------------------------------------------------------------------------------------
544 (
545  uint32_t msgId,
546  ///< [IN] Message identifier.
547  uint8_t* pduPtr,
548  ///< [OUT] PDU message.
549  size_t* pduSizePtr
550  ///< [INOUT]
551 );
552 
553 //--------------------------------------------------------------------------------------------------
554 /**
555  * Get the first Message object reference in the inbox message.
556  *
557  * @return
558  * - 0 No message found (message box parsing is over).
559  * - Message identifier.
560  */
561 //--------------------------------------------------------------------------------------------------
562 uint32_t le_smsInbox1_GetFirst
563 (
564  le_smsInbox1_SessionRef_t sessionRef
565  ///< [IN] Mailbox session reference.
566 );
567 
568 //--------------------------------------------------------------------------------------------------
569 /**
570  * Get the next Message object reference in the inbox message.
571  *
572  * @return
573  * - 0 No message found (message box parsing is over).
574  * - Message identifier.
575  */
576 //--------------------------------------------------------------------------------------------------
577 uint32_t le_smsInbox1_GetNext
578 (
579  le_smsInbox1_SessionRef_t sessionRef
580  ///< [IN] Mailbox session reference.
581 );
582 
583 //--------------------------------------------------------------------------------------------------
584 /**
585  * allow to know whether the message has been read or not. The message status is tied to the client
586  * app.
587  *
588  * @return True if the message is unread, false otherwise.
589  *
590  * @note If the caller is passing a bad message reference into this function, it is a fatal error,
591  * the function will not return.
592  */
593 //--------------------------------------------------------------------------------------------------
595 (
596  uint32_t msgId
597  ///< [IN] Message identifier.
598 );
599 
600 //--------------------------------------------------------------------------------------------------
601 /**
602  * Mark a message as 'read'.
603  *
604  * @note If the caller is passing a bad message reference into this function, it is a fatal error,
605  * the function will not return.
606  */
607 //--------------------------------------------------------------------------------------------------
609 (
610  uint32_t msgId
611  ///< [IN] Message identifier.
612 );
613 
614 //--------------------------------------------------------------------------------------------------
615 /**
616  * Mark a message as 'unread'.
617  *
618  * @note If the caller is passing a bad message reference into this function, it is a fatal error,
619  * the function will not return.
620  */
621 //--------------------------------------------------------------------------------------------------
623 (
624  uint32_t msgId
625  ///< [IN] Message identifier.
626 );
627 
628 //--------------------------------------------------------------------------------------------------
629 /**
630  * Set the maximum number of messages for message box.
631  *
632  * @return
633  * - LE_BAD_PARAMETER The message box name is invalid.
634  * - LE_OVERFLOW Message count exceed the maximum limit.
635  * - LE_OK Function succeeded.
636  * - LE_FAULT Function failed.
637  */
638 //--------------------------------------------------------------------------------------------------
640 (
641  uint32_t maxMessageCount
642  ///< [IN] Maximum number of messages
643 );
644 
645 //--------------------------------------------------------------------------------------------------
646 /**
647  * Get the maximum number of messages for message box.
648  *
649  * @return
650  * - LE_BAD_PARAMETER The message box name is invalid.
651  * - LE_OK Function succeeded.
652  * - LE_FAULT Function failed.
653  */
654 //--------------------------------------------------------------------------------------------------
656 (
657  uint32_t* maxMessageCountPtrPtr
658  ///< [OUT] Maximum number of messages
659 );
660 
661 #endif // LE_SMSINBOX1_INTERFACE_H_INCLUDE_GUARD
le_result_t le_smsInbox1_GetPdu(uint32_t msgId, uint8_t *pduPtr, size_t *pduSizePtr)
le_result_t le_smsInbox1_GetText(uint32_t msgId, char *text, size_t textSize)
void le_smsInbox1_RemoveRxMessageHandler(le_smsInbox1_RxMessageHandlerRef_t handlerRef)
uint32_t le_smsInbox1_GetFirst(le_smsInbox1_SessionRef_t sessionRef)
le_result_t
Definition: le_basics.h:35
le_smsInbox1_SessionRef_t le_smsInbox1_Open(void)
size_t le_smsInbox1_GetMsgLen(uint32_t msgId)
uint32_t le_smsInbox1_GetNext(le_smsInbox1_SessionRef_t sessionRef)
void le_smsInbox1_DeleteMsg(uint32_t msgId)
le_smsInbox1_RxMessageHandlerRef_t le_smsInbox1_AddRxMessageHandler(le_smsInbox1_RxMessageHandlerFunc_t handlerPtr, void *contextPtr)
le_sms_Format_t
Definition: le_sms_interface.h:546
void le_smsInbox1_SetServerDisconnectHandler(le_smsInbox1_DisconnectHandler_t disconnectHandler, void *contextPtr)
le_result_t le_smsInbox1_GetImsi(uint32_t msgId, char *imsi, size_t imsiSize)
void le_smsInbox1_ConnectService(void)
le_sms_Format_t le_smsInbox1_GetFormat(uint32_t msgId)
bool le_smsInbox1_IsUnread(uint32_t msgId)
le_result_t le_smsInbox1_GetBinary(uint32_t msgId, uint8_t *binPtr, size_t *binSizePtr)
le_result_t le_smsInbox1_TryConnectService(void)
void le_smsInbox1_MarkUnread(uint32_t msgId)
struct le_smsInbox1_Session * le_smsInbox1_SessionRef_t
Definition: le_smsInbox1_interface.h:296
le_result_t le_smsInbox1_GetTimeStamp(uint32_t msgId, char *timestamp, size_t timestampSize)
void le_smsInbox1_DisconnectService(void)
void le_smsInbox1_MarkRead(uint32_t msgId)
void(* le_smsInbox1_DisconnectHandler_t)(void *)
Definition: le_smsInbox1_interface.h:200
le_result_t le_smsInbox1_GetMaxMessages(uint32_t *maxMessageCountPtrPtr)
void le_smsInbox1_Close(le_smsInbox1_SessionRef_t sessionRef)
struct le_smsInbox1_RxMessageHandler * le_smsInbox1_RxMessageHandlerRef_t
Definition: le_smsInbox1_interface.h:304
void(* le_smsInbox1_RxMessageHandlerFunc_t)(uint32_t msgId, void *contextPtr)
Definition: le_smsInbox1_interface.h:314
le_result_t le_smsInbox1_GetSenderTel(uint32_t msgId, char *tel, size_t telSize)
le_result_t le_smsInbox1_SetMaxMessages(uint32_t maxMessageCount)