le_smsInbox1_interface.h

    1 
    2 
    3 /*
    4  * ====================== WARNING ======================
    5  *
    6  * THE CONTENTS OF THIS FILE HAVE BEEN AUTO-GENERATED.
    7  * DO NOT MODIFY IN ANY WAY.
    8  *
    9  * ====================== WARNING ======================
   10  */
   11 
   12 /**
   13  * @page c_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 //--------------------------------------------------------------------------------------------------
  215 void le_smsInbox1_ConnectService
  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 //--------------------------------------------------------------------------------------------------
  240 le_result_t le_smsInbox1_TryConnectService
  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 //--------------------------------------------------------------------------------------------------
  253 void le_smsInbox1_SetServerDisconnectHandler
  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 //--------------------------------------------------------------------------------------------------
  271 void le_smsInbox1_DisconnectService
  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 //--------------------------------------------------------------------------------------------------
  313 typedef void (*le_smsInbox1_RxMessageHandlerFunc_t)
  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 //--------------------------------------------------------------------------------------------------
  329 le_smsInbox1_SessionRef_t le_smsInbox1_Open
  330 (
  331     void
  332 );
  333 
  334 //--------------------------------------------------------------------------------------------------
  335 /**
  336  * Close a previously open message box.
  337  *
  338  */
  339 //--------------------------------------------------------------------------------------------------
  340 void le_smsInbox1_Close
  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 //--------------------------------------------------------------------------------------------------
  354 le_smsInbox1_RxMessageHandlerRef_t le_smsInbox1_AddRxMessageHandler
  355 (
  356     le_smsInbox1_RxMessageHandlerFunc_t handlerPtr,
  357         ///< [IN]
  358     void* contextPtr
  359         ///< [IN]
  360 );
  361 
  362 //--------------------------------------------------------------------------------------------------
  363 /**
  364  * Remove handler function for EVENT 'le_smsInbox1_RxMessage'
  365  */
  366 //--------------------------------------------------------------------------------------------------
  367 void le_smsInbox1_RemoveRxMessageHandler
  368 (
  369     le_smsInbox1_RxMessageHandlerRef_t handlerRef
  370         ///< [IN]
  371 );
  372 
  373 //--------------------------------------------------------------------------------------------------
  374 /**
  375  * Delete a Message.
  376  *
  377  * @note It is valid to delete a non-existent message.
  378  */
  379 //--------------------------------------------------------------------------------------------------
  380 void le_smsInbox1_DeleteMsg
  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 //--------------------------------------------------------------------------------------------------
  399 le_result_t le_smsInbox1_GetImsi
  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 //--------------------------------------------------------------------------------------------------
  421 le_sms_Format_t le_smsInbox1_GetFormat
  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 //--------------------------------------------------------------------------------------------------
  437 le_result_t le_smsInbox1_GetSenderTel
  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 //--------------------------------------------------------------------------------------------------
  458 le_result_t le_smsInbox1_GetTimeStamp
  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 //--------------------------------------------------------------------------------------------------
  479 size_t le_smsInbox1_GetMsgLen
  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 //--------------------------------------------------------------------------------------------------
  497 le_result_t le_smsInbox1_GetText
  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 //--------------------------------------------------------------------------------------------------
  519 le_result_t le_smsInbox1_GetBinary
  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 //--------------------------------------------------------------------------------------------------
  543 le_result_t le_smsInbox1_GetPdu
  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 //--------------------------------------------------------------------------------------------------
  594 bool le_smsInbox1_IsUnread
  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 //--------------------------------------------------------------------------------------------------
  608 void le_smsInbox1_MarkRead
  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 //--------------------------------------------------------------------------------------------------
  622 void le_smsInbox1_MarkUnread
  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 //--------------------------------------------------------------------------------------------------
  639 le_result_t le_smsInbox1_SetMaxMessages
  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 //--------------------------------------------------------------------------------------------------
  655 le_result_t le_smsInbox1_GetMaxMessages
  656 (
  657     uint32_t* maxMessageCountPtrPtr
  658         ///< [OUT] Maximum number of messages
  659 );
  660 
  661 #endif // LE_SMSINBOX1_INTERFACE_H_INCLUDE_GUARD
le_smsInbox1_Open
le_smsInbox1_SessionRef_t le_smsInbox1_Open(void)
le_smsInbox1_GetTimeStamp
le_result_t le_smsInbox1_GetTimeStamp(uint32_t msgId, char *timestamp, size_t timestampSize)
le_mdmDefs_interface.h
le_smsInbox1_DeleteMsg
void le_smsInbox1_DeleteMsg(uint32_t msgId)
le_smsInbox1_DisconnectHandler_t
void(* le_smsInbox1_DisconnectHandler_t)(void *)
Definition: le_smsInbox1_interface.h:200
le_smsInbox1_GetImsi
le_result_t le_smsInbox1_GetImsi(uint32_t msgId, char *imsi, size_t imsiSize)
le_smsInbox1_MarkRead
void le_smsInbox1_MarkRead(uint32_t msgId)
le_smsInbox1_GetMaxMessages
le_result_t le_smsInbox1_GetMaxMessages(uint32_t *maxMessageCountPtrPtr)
le_result_t
le_result_t
Definition: le_basics.h:35
le_smsInbox1_SetMaxMessages
le_result_t le_smsInbox1_SetMaxMessages(uint32_t maxMessageCount)
le_smsInbox1_GetBinary
le_result_t le_smsInbox1_GetBinary(uint32_t msgId, uint8_t *binPtr, size_t *binSizePtr)
le_sms_interface.h
le_sms_Format_t
le_sms_Format_t
Definition: le_sms_interface.h:550
le_smsInbox1_MarkUnread
void le_smsInbox1_MarkUnread(uint32_t msgId)
le_sim_interface.h
le_smsInbox1_GetSenderTel
le_result_t le_smsInbox1_GetSenderTel(uint32_t msgId, char *tel, size_t telSize)
le_smsInbox1_SetServerDisconnectHandler
void le_smsInbox1_SetServerDisconnectHandler(le_smsInbox1_DisconnectHandler_t disconnectHandler, void *contextPtr)
le_smsInbox1_GetFormat
le_sms_Format_t le_smsInbox1_GetFormat(uint32_t msgId)
le_smsInbox1_TryConnectService
le_result_t le_smsInbox1_TryConnectService(void)
le_smsInbox1_RxMessageHandlerRef_t
struct le_smsInbox1_RxMessageHandler * le_smsInbox1_RxMessageHandlerRef_t
Definition: le_smsInbox1_interface.h:304
le_smsInbox1_GetMsgLen
size_t le_smsInbox1_GetMsgLen(uint32_t msgId)
le_smsInbox1_SessionRef_t
struct le_smsInbox1_Session * le_smsInbox1_SessionRef_t
Definition: le_smsInbox1_interface.h:296
le_smsInbox1_GetText
le_result_t le_smsInbox1_GetText(uint32_t msgId, char *text, size_t textSize)
le_smsInbox1_GetNext
uint32_t le_smsInbox1_GetNext(le_smsInbox1_SessionRef_t sessionRef)
legato.h
le_smsInbox1_RemoveRxMessageHandler
void le_smsInbox1_RemoveRxMessageHandler(le_smsInbox1_RxMessageHandlerRef_t handlerRef)
le_smsInbox1_AddRxMessageHandler
le_smsInbox1_RxMessageHandlerRef_t le_smsInbox1_AddRxMessageHandler(le_smsInbox1_RxMessageHandlerFunc_t handlerPtr, void *contextPtr)
le_smsInbox1_DisconnectService
void le_smsInbox1_DisconnectService(void)
le_smsInbox1_RxMessageHandlerFunc_t
void(* le_smsInbox1_RxMessageHandlerFunc_t)(uint32_t msgId, void *contextPtr)
Definition: le_smsInbox1_interface.h:314
le_smsInbox1_GetPdu
le_result_t le_smsInbox1_GetPdu(uint32_t msgId, uint8_t *pduPtr, size_t *pduSizePtr)
le_smsInbox1_GetFirst
uint32_t le_smsInbox1_GetFirst(le_smsInbox1_SessionRef_t sessionRef)
le_smsInbox1_IsUnread
bool le_smsInbox1_IsUnread(uint32_t msgId)
le_smsInbox1_Close
void le_smsInbox1_Close(le_smsInbox1_SessionRef_t sessionRef)
le_smsInbox1_ConnectService
void le_smsInbox1_ConnectService(void)