le_sms_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_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 //--------------------------------------------------------------------------------------------------
  418 void le_sms_ConnectService
  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 //--------------------------------------------------------------------------------------------------
  443 le_result_t le_sms_TryConnectService
  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 //--------------------------------------------------------------------------------------------------
  456 LE_FULL_API void le_sms_SetServerDisconnectHandler
  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 //--------------------------------------------------------------------------------------------------
  474 void le_sms_DisconnectService
  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 //--------------------------------------------------------------------------------------------------
  608 void le_sms_RemoveRxMessageHandler
  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 //--------------------------------------------------------------------------------------------------
  635 void le_sms_RemoveFullStorageEventHandler
  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 //--------------------------------------------------------------------------------------------------
  674 le_result_t le_sms_SetTimeout
  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 //--------------------------------------------------------------------------------------------------
  700 le_result_t le_sms_SetDestination
  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 //--------------------------------------------------------------------------------------------------
  726 le_result_t le_sms_SetText
  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 //--------------------------------------------------------------------------------------------------
  749 le_result_t le_sms_SetBinary
  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 //--------------------------------------------------------------------------------------------------
  775 le_result_t le_sms_SetUCS2
  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 //--------------------------------------------------------------------------------------------------
  800 le_result_t le_sms_SetPDU
  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 //--------------------------------------------------------------------------------------------------
  826 le_result_t le_sms_Send
  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 //--------------------------------------------------------------------------------------------------
  848 le_result_t le_sms_SendAsync
  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 //--------------------------------------------------------------------------------------------------
  889 void le_sms_GetErrorCode
  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 //--------------------------------------------------------------------------------------------------
  911 int32_t le_sms_GetPlatformSpecificErrorCode
  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 //--------------------------------------------------------------------------------------------------
 1029 le_result_t le_sms_GetCellBroadcastId
 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 //--------------------------------------------------------------------------------------------------
 1049 le_result_t le_sms_GetCellBroadcastSerialNumber
 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 //--------------------------------------------------------------------------------------------------
 1073 le_result_t le_sms_GetSenderTel
 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 //--------------------------------------------------------------------------------------------------
 1099 le_result_t le_sms_GetTimeStamp
 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 //--------------------------------------------------------------------------------------------------
 1146 le_result_t le_sms_GetText
 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 //--------------------------------------------------------------------------------------------------
 1172 le_result_t le_sms_GetBinary
 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 //--------------------------------------------------------------------------------------------------
 1197 le_result_t le_sms_GetUCS2
 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 //--------------------------------------------------------------------------------------------------
 1223 le_result_t le_sms_GetPDU
 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 //--------------------------------------------------------------------------------------------------
 1264 le_result_t le_sms_DeleteFromStorage
 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 //--------------------------------------------------------------------------------------------------
 1396 le_result_t le_sms_GetSmsCenterAddress
 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 //--------------------------------------------------------------------------------------------------
 1419 le_result_t le_sms_SetSmsCenterAddress
 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 //--------------------------------------------------------------------------------------------------
 1433 le_result_t le_sms_SetPreferredStorage
 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 //--------------------------------------------------------------------------------------------------
 1447 le_result_t le_sms_GetPreferredStorage
 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 //--------------------------------------------------------------------------------------------------
 1462 le_result_t le_sms_ActivateCellBroadcast
 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 //--------------------------------------------------------------------------------------------------
 1476 le_result_t le_sms_DeactivateCellBroadcast
 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 //--------------------------------------------------------------------------------------------------
 1490 le_result_t le_sms_ActivateCdmaCellBroadcast
 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 //--------------------------------------------------------------------------------------------------
 1504 le_result_t le_sms_DeactivateCdmaCellBroadcast
 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 //--------------------------------------------------------------------------------------------------
 1518 le_result_t le_sms_AddCellBroadcastIds
 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 //--------------------------------------------------------------------------------------------------
 1535 le_result_t le_sms_RemoveCellBroadcastIds
 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 //--------------------------------------------------------------------------------------------------
 1552 le_result_t le_sms_ClearCellBroadcastIds
 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 //--------------------------------------------------------------------------------------------------
 1567 le_result_t le_sms_AddCdmaCellBroadcastServices
 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 //--------------------------------------------------------------------------------------------------
 1588 le_result_t le_sms_RemoveCdmaCellBroadcastServices
 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 //--------------------------------------------------------------------------------------------------
 1608 le_result_t le_sms_ClearCdmaCellBroadcastServices
 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 //--------------------------------------------------------------------------------------------------
 1625 le_result_t le_sms_GetCount
 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 //--------------------------------------------------------------------------------------------------
 1672 le_result_t le_sms_EnableStatusReport
 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 //--------------------------------------------------------------------------------------------------
 1686 le_result_t le_sms_DisableStatusReport
 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 //--------------------------------------------------------------------------------------------------
 1701 le_result_t le_sms_IsStatusReportEnabled
 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 //--------------------------------------------------------------------------------------------------
 1720 le_result_t le_sms_GetTpMr
 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 //--------------------------------------------------------------------------------------------------
 1741 le_result_t le_sms_GetTpRa
 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 //--------------------------------------------------------------------------------------------------
 1766 le_result_t le_sms_GetTpScTs
 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 //--------------------------------------------------------------------------------------------------
 1788 le_result_t le_sms_GetTpDt
 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 //--------------------------------------------------------------------------------------------------
 1809 le_result_t le_sms_GetTpSt
 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_sms_SetServerDisconnectHandler
LE_FULL_API void le_sms_SetServerDisconnectHandler(le_sms_DisconnectHandler_t disconnectHandler, void *contextPtr)
le_sms_Delete
void le_sms_Delete(le_sms_MsgRef_t msgRef)
le_sms_GetPDU
le_result_t le_sms_GetPDU(le_sms_MsgRef_t msgRef, uint8_t *pduPtr, size_t *pduSizePtr)
le_sms_GetCellBroadcastId
le_result_t le_sms_GetCellBroadcastId(le_sms_MsgRef_t msgRef, uint16_t *messageIdPtr)
le_mdmDefs_interface.h
le_sms_ClearCdmaCellBroadcastServices
le_result_t le_sms_ClearCdmaCellBroadcastServices(void)
le_sms_GetSmsCenterAddress
le_result_t le_sms_GetSmsCenterAddress(char *tel, size_t telSize)
le_sms_StartCount
void le_sms_StartCount(void)
le_result_t
le_result_t
Definition: le_basics.h:35
le_sms_Get3GPP2ErrorCode
le_sms_ErrorCode3GPP2_t le_sms_Get3GPP2ErrorCode(le_sms_MsgRef_t msgRef)
le_sms_ClearCellBroadcastIds
le_result_t le_sms_ClearCellBroadcastIds(void)
le_sms_MarkUnread
void le_sms_MarkUnread(le_sms_MsgRef_t msgRef)
le_sms_Create
le_sms_MsgRef_t le_sms_Create(void)
le_sms_SetUCS2
le_result_t le_sms_SetUCS2(le_sms_MsgRef_t msgRef, const uint16_t *ucs2Ptr, size_t ucs2Size)
le_sms_GetUserdataLen
size_t le_sms_GetUserdataLen(le_sms_MsgRef_t msgRef)
le_sms_GetTpRa
le_result_t le_sms_GetTpRa(le_sms_MsgRef_t msgRef, uint8_t *toraPtr, char *ra, size_t raSize)
le_sms_SetTimeout
le_result_t le_sms_SetTimeout(le_sms_MsgRef_t msgRef, uint32_t timeout)
le_sms_SendPdu
le_sms_MsgRef_t le_sms_SendPdu(const uint8_t *pduPtr, size_t pduSize, le_sms_CallbackResultFunc_t handlerPtr, void *contextPtr)
le_sms_DisconnectHandler_t
void(* le_sms_DisconnectHandler_t)(void *)
Definition: le_sms_interface.h:403
le_sms_GetErrorCode
void le_sms_GetErrorCode(le_sms_MsgRef_t msgRef, le_sms_ErrorCode_t *rpCausePtr, le_sms_ErrorCode_t *tpCausePtr)
le_sms_ActivateCellBroadcast
le_result_t le_sms_ActivateCellBroadcast(void)
le_sms_GetNext
le_sms_MsgRef_t le_sms_GetNext(le_sms_MsgListRef_t msgListRef)
le_sms_GetBinary
le_result_t le_sms_GetBinary(le_sms_MsgRef_t msgRef, uint8_t *binPtr, size_t *binSizePtr)
le_sms_CreateRxMsgList
le_sms_MsgListRef_t le_sms_CreateRxMsgList(void)
le_sms_RemoveRxMessageHandler
void le_sms_RemoveRxMessageHandler(le_sms_RxMessageHandlerRef_t handlerRef)
le_sms_GetText
le_result_t le_sms_GetText(le_sms_MsgRef_t msgRef, char *text, size_t textSize)
le_sms_ActivateCdmaCellBroadcast
le_result_t le_sms_ActivateCdmaCellBroadcast(void)
le_sms_AddFullStorageEventHandler
le_sms_FullStorageEventHandlerRef_t le_sms_AddFullStorageEventHandler(le_sms_FullStorageHandlerFunc_t handlerPtr, void *contextPtr)
le_sms_DeactivateCellBroadcast
le_result_t le_sms_DeactivateCellBroadcast(void)
le_sms_GetCellBroadcastSerialNumber
le_result_t le_sms_GetCellBroadcastSerialNumber(le_sms_MsgRef_t msgRef, uint16_t *serialNumberPtr)
le_sms_DisableStatusReport
le_result_t le_sms_DisableStatusReport(void)
le_sms_DisconnectService
void le_sms_DisconnectService(void)
le_sms_TryConnectService
le_result_t le_sms_TryConnectService(void)
le_sms_AddCellBroadcastIds
le_result_t le_sms_AddCellBroadcastIds(uint16_t fromId, uint16_t toId)
le_sms_SetText
le_result_t le_sms_SetText(le_sms_MsgRef_t msgRef, const char *LE_NONNULL text)
le_sms_SetBinary
le_result_t le_sms_SetBinary(le_sms_MsgRef_t msgRef, const uint8_t *binPtr, size_t binSize)
le_sms_SetPreferredStorage
le_result_t le_sms_SetPreferredStorage(le_sms_Storage_t prefStorage)
le_sms_DeleteFromStorage
le_result_t le_sms_DeleteFromStorage(le_sms_MsgRef_t msgRef)
le_sms_GetUCS2
le_result_t le_sms_GetUCS2(le_sms_MsgRef_t msgRef, uint16_t *ucs2Ptr, size_t *ucs2SizePtr)
le_sms_GetSenderTel
le_result_t le_sms_GetSenderTel(le_sms_MsgRef_t msgRef, char *tel, size_t telSize)
le_sms_SendAsync
le_result_t le_sms_SendAsync(le_sms_MsgRef_t msgRef, le_sms_CallbackResultFunc_t handlerPtr, void *contextPtr)
le_sms_GetStatus
le_sms_Status_t le_sms_GetStatus(le_sms_MsgRef_t msgRef)
le_sms_GetPreferredStorage
le_result_t le_sms_GetPreferredStorage(le_sms_Storage_t *prefStoragePtr)
le_sms_GetPDULen
size_t le_sms_GetPDULen(le_sms_MsgRef_t msgRef)
le_sms_DeactivateCdmaCellBroadcast
le_result_t le_sms_DeactivateCdmaCellBroadcast(void)
le_sms_RemoveCdmaCellBroadcastServices
le_result_t le_sms_RemoveCdmaCellBroadcastServices(le_sms_CdmaServiceCat_t serviceCat, le_sms_Languages_t language)
le_sms_SetSmsCenterAddress
le_result_t le_sms_SetSmsCenterAddress(const char *LE_NONNULL tel)
le_sms_GetFirst
le_sms_MsgRef_t le_sms_GetFirst(le_sms_MsgListRef_t msgListRef)
le_sms_ResetCount
void le_sms_ResetCount(void)
le_sms_SetPDU
le_result_t le_sms_SetPDU(le_sms_MsgRef_t msgRef, const uint8_t *pduPtr, size_t pduSize)
le_sms_RemoveCellBroadcastIds
le_result_t le_sms_RemoveCellBroadcastIds(uint16_t fromId, uint16_t toId)
le_sms_ConnectService
void le_sms_ConnectService(void)
le_sms_SendText
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_sms_SetDestination
le_result_t le_sms_SetDestination(le_sms_MsgRef_t msgRef, const char *LE_NONNULL dest)
le_sms_GetTpDt
le_result_t le_sms_GetTpDt(le_sms_MsgRef_t msgRef, char *dt, size_t dtSize)
le_sms_AddCdmaCellBroadcastServices
le_result_t le_sms_AddCdmaCellBroadcastServices(le_sms_CdmaServiceCat_t serviceCat, le_sms_Languages_t language)
le_sms_GetTpMr
le_result_t le_sms_GetTpMr(le_sms_MsgRef_t msgRef, uint8_t *tpMrPtr)
LE_FULL_API
#define LE_FULL_API
Definition: le_basics.h:288
le_sms_EnableStatusReport
le_result_t le_sms_EnableStatusReport(void)
le_sms_GetFormat
le_sms_Format_t le_sms_GetFormat(le_sms_MsgRef_t msgRef)
le_sms_GetPlatformSpecificErrorCode
int32_t le_sms_GetPlatformSpecificErrorCode(le_sms_MsgRef_t msgRef)
le_sms_GetCount
le_result_t le_sms_GetCount(le_sms_Type_t messageType, int32_t *messageCountPtr)
le_sms_GetType
le_sms_Type_t le_sms_GetType(le_sms_MsgRef_t msgRef)
le_sms_RemoveFullStorageEventHandler
void le_sms_RemoveFullStorageEventHandler(le_sms_FullStorageEventHandlerRef_t handlerRef)
le_sms_GetTpSt
le_result_t le_sms_GetTpSt(le_sms_MsgRef_t msgRef, uint8_t *stPtr)
le_sms_GetTimeStamp
le_result_t le_sms_GetTimeStamp(le_sms_MsgRef_t msgRef, char *timestamp, size_t timestampSize)
le_sms_Send
le_result_t le_sms_Send(le_sms_MsgRef_t msgRef)
le_sms_DeleteList
void le_sms_DeleteList(le_sms_MsgListRef_t msgListRef)
le_sms_AddRxMessageHandler
le_sms_RxMessageHandlerRef_t le_sms_AddRxMessageHandler(le_sms_RxMessageHandlerFunc_t handlerPtr, void *contextPtr)
le_sms_IsStatusReportEnabled
le_result_t le_sms_IsStatusReportEnabled(bool *enabledPtr)
le_sms_MarkRead
void le_sms_MarkRead(le_sms_MsgRef_t msgRef)
le_sms_GetTpScTs
le_result_t le_sms_GetTpScTs(le_sms_MsgRef_t msgRef, char *scts, size_t sctsSize)
le_sms_StopCount
void le_sms_StopCount(void)