include/mapi/msg_transport.h

   1 /*
   2 * Copyright 2012-2013  Samsung Electronics Co., Ltd
   3 *
   4 * Licensed under the Flora License, Version 1.1 (the "License");
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 *    http://floralicense.org/license/
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an "AS IS" BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16
  17 /**
  18  *      @file           MapiTransport.h
  19  *      @brief          Defines transport API of messaging framework
  20  *      @version        1.0
  21  */
  22
  23 #ifndef MAPI_TRANSPORT_H
  24 #define MAPI_TRANSPORT_H
  25
  26 /**
  27  *      @section                Introduction
  28  *      - Introduction : Overview on Messaging Transport API
  29  *      @section                Program
  30  *      - Program : Messaging Transport API Reference
  31  */
  32
  33 /*==================================================================================================
  34                                          INCLUDE FILES
  35 ==================================================================================================*/
  36
  37 #include "msg_transport_types.h"
  38
  39 #ifdef __cplusplus
  40 extern "C"
  41 {
  42 #endif
  43
  44 /**
  45  *      @ingroup                MESSAGING_FRAMEWORK
  46  *      @defgroup       MESSAGING_TRANSPORT_API Messaging Transport API
  47  *      @{
  48  */
  49
  50 /*==================================================================================================
  51                                      FUNCTION PROTOTYPES
  52 ==================================================================================================*/
  53
  54 /**
  55
  56  * \par Description:
  57  * Submits a request to the Messaging Framework.
  58  *
  59  * \par Purpose:
  60  * This API is used to submit a request to the Messaging Framework.
  61  *
  62  * \par Typical use case:
  63  * Submit a request to Messaging Service such as Send Message, Forward etc.
  64  *
  65  * \par Method of function operation:
  66  * Sets up the database connection and inserts the message to message table.
  67  *
  68  * \par Sync (or) Async:
  69  * This is a Synchronous API.
  70  *
  71  * \par Important notes:
  72  * - The result information will be sent back by using the callback function, msg_sent_status_cb.
  73  * - Applications MUST fill in the valid message type.
  74  * -  reqId will be filled in the framework.
  75  *
  76  * \param input  - handle is Message handle.
  77  * \param input  - req is a pointer to an MSG_REQUEST_S structure.
  78  *
  79  * \return Return Type (int(msg_error_t)) \n
  80  * - MSG_SUCCESS                                        Success in operation.
  81  * - MSG_ERR_INVALID_MSGHANDLE  Message handle is invalid.
  82  * - MSG_ERR_NULL_POINTER                       Pointer is NULL.
  83  *
  84  * \par Prospective clients:
  85  * External/Native Apps using Messaging Services.
  86  *
  87  * \par Related functions:
  88  * None
  89  *
  90  * \par Known issues/bugs:
  91  * None
  92  *
  93  * \par Sample code:
  94  * \code
  95  * ...
  96  *
  97  * int err = MSG_SUCCESS;
  98  * MSG_REQUEST_S req;
  99  *
 100  * req.msg = msg;
 101  * req.sendOpt = sendOpt;
 102
 103  * err = msg_submit_req(msgHandle, &req);
 104  * if (err != MSG_SUCCESS)
 105  * {
 106  * ...
 107  * }
 108  *
 109  * ...
 110  * \endcode
 111  */
 112 /*================================================================================================*/
 113 int msg_submit_req(msg_handle_t handle, msg_struct_t req);
 114
 115
 116 /**
 117
 118  * \par Description:
 119  * Registers sent status callback function to Message handle.
 120  *
 121  * \par Purpose:
 122  * This API is used to register sent status callback function "msg_sent_status_cb" to Message handle.
 123  *
 124  * \par Typical use case:
 125  * Register for sent status callback.
 126  *
 127  * \par Method of function operation:
 128  * Adds the msg_sent_status_cb API to sent status callback list.
 129  *
 130  * \par Sync (or) Async:
 131  * This is a Synchronous API.
 132  *
 133  * \par Important notes:
 134  *      This function MUST be called after Message handle is opened.
 135  *
 136  * \param input - handle is Message handle.
 137  * \param input - cb is a function to be called.
 138  * \param input - user_param is a pointer to user data.
 139  *
 140  * \return Return Type (int(msg_error_t)) \n
 141  * - MSG_SUCCESS                                        Success in operation.
 142  * - MSG_ERR_INVALID_MSGHANDLE  Message handle is invalid.
 143  *
 144  * \par Prospective clients:
 145  * External/Native Apps using Messaging Services.
 146  *
 147  * \par Related functions:
 148  * None
 149  *
 150  * \par Known issues/bugs:
 151  * None
 152  *
 153  * \par Sample code:
 154  * \code
 155  * ...
 156  *
 157  * int err = MSG_SUCCESS;
 158  * MSG_REQUEST_S req;
 159  *
 160  * req.msg = msg;
 161  * req.sendOpt = sendOpt;
 162
 163  * err = msg_reg_sent_status_callback(msgHandle, &sentStatusCB, (void*)"sent status callback");
 164  * if (err != MSG_SUCCESS)
 165  * {
 166  * ...
 167  * }
 168  * return;
 169  * }
 170
 171  * void sentStatusCB(msg_handle_t Handle, MSG_SENT_STATUS_S *pStatus, void *pUserParam)
 172  * {
 173  *      ...
 174  * }
 175  * ...
 176  * \endcode
 177  */
 178 /*================================================================================================*/
 179 int msg_reg_sent_status_callback(msg_handle_t handle, msg_sent_status_cb cb, void *user_param);
 180
 181
 182 /**
 183
 184  * \par Description:
 185  * Registers incoming SMS callback to Message handle.
 186  *
 187  * \par Purpose:
 188  * This API is used to Registers incoming SMS callback function "msg_sms_incoming_cb" to Message handle.
 189  *
 190  * \par Typical use case:
 191  * Register incoming SMS message callback.
 192  *
 193  * \par Method of function operation:
 194  * Adds the msg_sms_incoming_cb API to incoming SMS callback list.
 195  *
 196  * \par Sync (or) Async:
 197  * This is a Synchronous API.
 198  *
 199  * \par Important notes:
 200  *      This function MUST be called after Message handle is opened.
 201  *
 202  * \param input - handle is Message handle.
 203  * \param input - cb is a function to be called.
 204  * \param input - port is used for listening. If port is not used, please assign 0 to it.
 205  * \param input - user_param is a pointer to user data.
 206  *
 207  * \return Return Type (int(msg_error_t)) \n
 208  * - MSG_SUCCESS                                        Success in operation.
 209  * - MSG_ERR_INVALID_MSGHANDLE  Message handle is invalid.
 210  *
 211  * \par Prospective clients:
 212  * External/Native Apps using Messaging Services.
 213  *
 214  * \par Related functions:
 215  * None
 216  *
 217  * \par Known issues/bugs:
 218  * None
 219  *
 220  * \par Sample code:
 221  * \code
 222  * ...
 223  *
 224  * int err = MSG_SUCCESS;
 225  * MSG_REQUEST_S req;
 226  *
 227  * req.msg = msg;
 228  * req.sendOpt = sendOpt;
 229
 230  * err = msg_reg_sms_message_callback(msgHandle, &incomingSmsCB, 0, (void*)"sms message callback");
 231  * if (err != MSG_SUCCESS)
 232  * {
 233  * ...
 234  * }
 235  * return;
 236  * }
 237  *
 238  * void incomingSmsCB(msg_handle_t Handle, msg_message_t msg, void *pUserParam)
 239  * {
 240  *      ...
 241  * }
 242  * ...
 243  * \endcode
 244  */
 245 /*================================================================================================*/
 246 int msg_reg_sms_message_callback(msg_handle_t handle, msg_sms_incoming_cb cb, unsigned short port, void *user_param);
 247
 248
 249 /**
 250
 251  * \par Description:
 252  * Registers incoming MMS callback to Message handle.
 253  *
 254  * \par Purpose:
 255  * This API is used to Registers incoming MMS callback function "msg_mms_conf_msg_incoming_cb" to Message handle.
 256  *
 257  * \par Typical use case:
 258  * Register incoming SMS message callback.
 259  *
 260  * \par Method of function operation:
 261  * Adds the msg_mms_conf_msg_incoming_cb API to incoming MMS callback list.
 262  *
 263  * \par Sync (or) Async:
 264  * This is a Synchronous API.
 265  *
 266  * \par Important notes:
 267  *      This function MUST be called after Message handle is opened.
 268  *
 269  * \param input - handle is Message handle.
 270  * \param input - handle is Message handle.
 271  * \param input - cb is a function to be called.
 272  * \param input - app_id is used for listening. If appId is not used, please assign NULL to it.
 273  * \param input - user_param is a pointer to user data.
 274  *
 275  * \return Return Type (int(msg_error_t)) \n
 276  * - MSG_SUCCESS                                        Success in operation.
 277  * - MSG_ERR_INVALID_MSGHANDLE  Message handle is invalid.
 278  *
 279  * \par Prospective clients:
 280  * External/Native Apps using Messaging Services.
 281  *
 282  * \par Related functions:
 283  * None
 284  *
 285  * \par Known issues/bugs:
 286  * None
 287  *
 288  * \par Sample code:
 289  * \code
 290  * ...
 291  *
 292  * int err = MSG_SUCCESS;
 293  * MSG_REQUEST_S req;
 294  *
 295  * req.msg = msg;
 296  * req.sendOpt = sendOpt;
 297
 298  * err = msg_reg_mms_conf_message_callback(msgHandle, &incomingMmsConfCB, NULL, NULL);
 299  * if (err != MSG_SUCCESS)
 300  * {
 301  * ...
 302  * }
 303  * return;
 304  * }
 305  *
 306  * void incomingMmsConfCB(msg_handle_t Handle, msg_message_t msg, void *pUserParam)
 307  * {
 308  *      ...
 309  * }
 310  * ...
 311  * \endcode
 312  */
 313 /*================================================================================================*/
 314 int msg_reg_mms_conf_message_callback(msg_handle_t handle, msg_mms_conf_msg_incoming_cb cb, const char *app_id, void *user_param);
 315
 316
 317 /**
 318
 319  * \par Description:
 320  * Registers incoming SyncML Message callback to Message handle.
 321  *
 322  * \par Purpose:
 323  * This API is used to Registers incoming SyncML Message callback function "msg_syncml_msg_incoming_cb" to Message handle.
 324  *
 325  * \par Typical use case:
 326  * Register incoming SMS message callback.
 327  *
 328  * \par Method of function operation:
 329  * Adds the msg_syncml_msg_incoming_cb API to incoming SyncML callback list.
 330  *
 331  * \par Sync (or) Async:
 332  * This is a Synchronous API.
 333  *
 334  * \par Important notes:
 335  *      This function MUST be called after Message handle is opened.
 336  *
 337  * \param input - handle is Message handle.
 338  * \param input - cb is a function to be called.
 339  * \param input - user_param is a pointer to user data.
 340  *
 341  * \return Return Type (int(msg_error_t)) \n
 342  * - MSG_SUCCESS                                                        Success in operation.
 343  * - MSG_ERR_MSGHANDLE_NOT_CONNECTED    Message handle is not connected.
 344  * - MSG_ERR_MEMORY_ERROR                               Memory is error.
 345  *
 346  * \par Prospective clients:
 347  * External/Native Apps using Messaging Services.
 348  *
 349  * \par Related functions:
 350  * None
 351  *
 352  * \par Known issues/bugs:
 353  * None
 354  *
 355  * \par Sample code:
 356  * \code
 357  * ...
 358  *
 359  * int err = MSG_SUCCESS;
 360  *
 361  * err = err = msg_reg_syncml_message_callback(msgHandle, &syncMLCB, NULL);
 362  * if (err != MSG_SUCCESS)
 363  * {
 364  * ...
 365  * }
 366  * return;
 367  * }
 368  *
 369  * void syncMLCB(msg_handle_t hMsgHandle, msg_syncml_message_type_t msgType, const char* pPushHeader, int PushHeaderLen, const char* pPushBody, int PushBodyLen, void *pUserParam)
 370  * {
 371  *      ...
 372  * }
 373  * ...
 374  * \endcode
 375  */
 376 /*================================================================================================*/
 377 int msg_reg_syncml_message_callback(msg_handle_t handle,  msg_syncml_msg_incoming_cb cb, void *user_param);
 378
 379
 380 /**
 381
 382  * \par Description:
 383  * Registers incoming LBS Message callback to Message handle.
 384  *
 385  * \par Purpose:
 386  * This API is used to Registers incoming LBS Message callback function "msg_lbs_msg_incoming_cb" to Message handle.
 387  *
 388  * \par Typical use case:
 389  * Register incoming SMS message callback.
 390  *
 391  * \par Method of function operation:
 392  * Adds the msg_lbs_msg_incoming_cb API to incoming LBS Message callback list.
 393  *
 394  * \par Sync (or) Async:
 395  * This is a Synchronous API.
 396  *
 397  * \par Important notes:
 398  *      This function MUST be called after Message handle is opened.
 399  *
 400  * \param input - handle is Message handle.
 401  * \param input - cb is a function to be called.
 402  * \param input - user_param is a pointer to user data.
 403  *
 404  * \return Return Type (int(msg_error_t)) \n
 405  * - MSG_SUCCESS                                                        Success in operation.
 406  * - MSG_ERR_MSGHANDLE_NOT_CONNECTED    Message handle is not connected.
 407  * - MSG_ERR_MEMORY_ERROR                               Memory is error.
 408  *
 409  * \par Prospective clients:
 410  * External/Native Apps using Messaging Services.
 411  *
 412  * \par Related functions:
 413  * None
 414  *
 415  * \par Known issues/bugs:
 416  * None
 417  *
 418  * \par Sample code:
 419  * \code
 420  * ...
 421  *
 422  * int err = MSG_SUCCESS;
 423  *
 424  * err = msg_reg_lbs_message_callback(msgHandle, &lbsCB, NULL);
 425  * if (err != MSG_SUCCESS)
 426  * {
 427  * ...
 428  * }
 429  * return;
 430  * }
 431  *
 432  * void lbsCB(msg_handle_t hMsgHandle, const char* pPushHeader, const char* pPushBody, int pushBodyLen, void *pUserParam)
 433  * {
 434  *      ...
 435  * }
 436  * ...
 437  * \endcode
 438  */
 439 /*================================================================================================*/
 440 int msg_reg_lbs_message_callback(msg_handle_t handle, msg_lbs_msg_incoming_cb cb, void *user_param);
 441
 442
 443 /**
 444
 445  * \par Description:
 446  * Registers incoming LBS Message callback to Message handle.
 447  *
 448  * \par Purpose:
 449  * This API is used to Registers incoming LBS Message callback function "msg_lbs_msg_incoming_cb" to Message handle.
 450  *
 451  * \par Typical use case:
 452  * Register incoming SMS message callback.
 453  *
 454  * \par Method of function operation:
 455  * Adds the msg_lbs_msg_incoming_cb API to incoming LBS Message callback list.
 456  *
 457  * \par Sync (or) Async:
 458  * This is a Synchronous API.
 459  *
 460  * \par Important notes:
 461  *      This function MUST be called after Message handle is opened.
 462  *
 463  * \param input - handle is Message handle.
 464  * \param input - cb is a function to be called.
 465  * \param input - user_param is a pointer to user data.
 466  *
 467  * \return Return Type (int(msg_error_t)) \n
 468  * - MSG_SUCCESS                                                        Success in operation.
 469  * - MSG_ERR_MSGHANDLE_NOT_CONNECTED    Message handle is not connected.
 470  * - MSG_ERR_MEMORY_ERROR                               Memory is error.
 471  *
 472  * \par Prospective clients:
 473  * External/Native Apps using Messaging Services.
 474  *
 475  * \par Related functions:
 476  * None
 477  *
 478  * \par Known issues/bugs:
 479  * None
 480  *
 481  * \par Sample code:
 482  * \code
 483  * ...
 484  *
 485  * int err = MSG_SUCCESS;
 486  *
 487  * err = msg_reg_lbs_message_callback(msgHandle, &lbsCB, NULL);
 488  * if (err != MSG_SUCCESS)
 489  * {
 490  * ...
 491  * }
 492  * return;
 493  * }
 494  *
 495  * void lbsCB(msg_handle_t hMsgHandle, const char* pPushHeader, const char* pPushBody, int pushBodyLen, void *pUserParam)
 496  * {
 497  *      ...
 498  * }
 499  * ...
 500  * \endcode
 501  */
 502 /*================================================================================================*/
 503 int msg_reg_syncml_message_operation_callback(msg_handle_t handle,  msg_syncml_msg_operation_cb cb, void *user_param);
 504
 505
 506 int msg_reg_push_message_callback(msg_handle_t handle,  msg_push_msg_incoming_cb cb, const char *app_id, void *user_param);
 507
 508 int msg_reg_cb_message_callback(msg_handle_t handle, msg_cb_incoming_cb  cb, bool bsave, void *user_param);
 509
 510 /**
 511
 512  * \par Description:
 513  * Registers incoming LBS Message callback to Message handle.
 514  *
 515  * \par Purpose:
 516  * This API is used to Registers incoming LBS Message callback function "msg_lbs_msg_incoming_cb" to Message handle.
 517  *
 518  * \par Typical use case:
 519  * Register incoming SMS message callback.
 520  *
 521  * \par Method of function operation:
 522  * Adds the msg_lbs_msg_incoming_cb API to incoming LBS Message callback list.
 523  *
 524  * \par Sync (or) Async:
 525  * This is a Synchronous API.
 526  *
 527  * \par Important notes:
 528  *      This function MUST be called after Message handle is opened.
 529  *
 530  * \param input - handle is Message handle.
 531  * \param input - cb is a function to be called.
 532  * \param input - user_param is a pointer to user data.
 533  *
 534  * \return Return Type (int(msg_error_t)) \n
 535  * - MSG_SUCCESS                                                        Success in operation.
 536  * - MSG_ERR_MSGHANDLE_NOT_CONNECTED    Message handle is not connected.
 537  * - MSG_ERR_MEMORY_ERROR                               Memory is error.
 538  *
 539  * \par Prospective clients:
 540  * External/Native Apps using Messaging Services.
 541  *
 542  * \par Related functions:
 543  * None
 544  *
 545  * \par Known issues/bugs:
 546  * None
 547  *
 548  * \par Sample code:
 549  * \code
 550  * ...
 551  *
 552  * int err = MSG_SUCCESS;
 553  *
 554  * err = msg_reg_lbs_message_callback(msgHandle, &lbsCB, NULL);
 555  * if (err != MSG_SUCCESS)
 556  * {
 557  * ...
 558  * }
 559  * return;
 560  * }
 561  *
 562  * void lbsCB(msg_handle_t hMsgHandle, const char* pPushHeader, const char* pPushBody, int pushBodyLen, void *pUserParam)
 563  * {
 564  *      ...
 565  * }
 566  * ...
 567  * \endcode
 568  */
 569 /*================================================================================================*/
 570 int msg_syncml_message_operation(msg_handle_t handle,  msg_message_id_t msgId);
 571
 572
 573 /**
 574
 575  * \par Description:
 576  * Sends SMS. It is a synchronous API which has been blocked until sent status arrives.
 577  *
 578  * \par Purpose:
 579  * This API is used to sends SMS.
 580  *
 581  * \par Typical use case:
 582  * Sends a SMS Message
 583  *
 584  * \par Method of function operation:
 585  * It is a synchronous API which has been blocked until sent status arrives.
 586  *
 587  * \par Sync (or) Async:
 588  * This is a Synchronous API.
 589  *
 590  * \par Important notes:
 591  * - None
 592  *
 593  * \param input  - phone_num is the list of phone numbers. It is separated by ",".
 594  * \param input  - sms_text is a SMS text.
 595  * \param input  - cb is a function to be called.
 596  * \param input  - user_param is for user data.
 597  *
 598  * \return Return Type (int(msg_error_t)) \n
 599  * - MSG_SUCCESS                                Success in operation.
 600  * - MSG_ERR_NULL_POINTER               Invalid parameter.
 601  * - MSG_ERR_MEMORY_ERROR       Memory is error.
 602  *
 603  * \par Prospective clients:
 604  * External/Native Apps using Messaging Services.
 605  *
 606  * \par Related functions:
 607  * None
 608  *
 609  * \par Known issues/bugs:
 610  * None
 611  *
 612  * \par Sample code:
 613  * \code
 614  * ...
 615  *
 616  * int err = MSG_SUCCESS;
 617  *
 618  * err = msg_sms_send("01000000000,01000000000", "1234567890", sentStatusCB, NULL);
 619  * if (err != MSG_SUCCESS)
 620  * {
 621  * ...
 622  * }
 623  *
 624  * ...
 625  * \endcode
 626  */
 627 /*================================================================================================*/
 628 int msg_sms_send(const char *phone_num, const char *sms_text, msg_simple_sent_status_cb cb, void *user_param);
 629
 630
 631 /**
 632
 633  * \par Description:
 634  * Submits request to send SMS message.
 635  *
 636  * \par Purpose:
 637  * This API is used to submit request to send SMS message.
 638  *
 639  * \par Typical use case:
 640  * Submits request to send SMS message.
 641  *
 642  * \par Method of function operation:
 643  * Submits a request to send SMS.
 644  *
 645  * \par Sync (or) Async:
 646  * This is a Synchronous API.
 647  *
 648  * \par Important notes:
 649  * - None
 650  *
 651  * \param input  - phone_num is the list of phone numbers. It is separated by ",".
 652  * \param input  - sms_text is a SMS text.
 653  * \param input  - cb is a function to be called.
 654  * \param input  - user_param is for user data.
 655  *
 656  * \return Return Type (int(msg_error_t)) \n
 657  * - MSG_SUCCESS                                Success in operation.
 658  * - MSG_ERR_NULL_POINTER               Invalid parameter.
 659  * - MSG_ERR_MEMORY_ERROR       Memory is error.
 660  *
 661  * \par Prospective clients:
 662  * External/Native Apps using Messaging Services.
 663  *
 664  * \par Related functions:
 665  * None
 666  *
 667  * \par Known issues/bugs:
 668  * None
 669  *
 670  * \par Sample code:
 671  * \code
 672  * ...
 673  *
 674  * int err = MSG_SUCCESS;
 675  * MSG_REQUEST_S req;
 676  *
 677  * req.msg = msg;
 678  * req.sendOpt = sendOpt;
 679  *
 680  * err = msg_sms_send_message(msgHandle, &req);
 681  * if (err != MSG_SUCCESS)
 682  * {
 683  * ...
 684  * }
 685  *
 686  * ...
 687  * \endcode
 688  */
 689 /*================================================================================================*/
 690 int msg_sms_send_message(msg_handle_t handle, msg_struct_t req);
 691
 692
 693 /**
 694
 695  * \par Description:
 696  * Submits request to send MMS message.
 697  *
 698  * \par Purpose:
 699  * This API is used to submit request to send MMS message.
 700  *
 701  * \par Typical use case:
 702  * Submits request to send MMS message.
 703  *
 704  * \par Method of function operation:
 705  * Submits a request to send MMS.
 706  *
 707  * \par Sync (or) Async:
 708  * This is a Synchronous API.
 709  *
 710  * \par Important notes:
 711  * - None
 712  *
 713  * \param input  - handle is Message handle.
 714  * \param input  - req is a pointer to an MSG_REQUEST_S structure.
 715  *
 716  * \return Return Type (int(msg_error_t)) \n
 717  * - MSG_SUCCESS                                Success in operation.
 718  * - MSG_ERR_NULL_POINTER               Invalid parameter.
 719  * - MSG_ERR_MEMORY_ERROR       Memory is error.
 720  *
 721  * \par Prospective clients:
 722  * External/Native Apps using Messaging Services.
 723  *
 724  * \par Related functions:
 725  * None
 726  *
 727  * \par Known issues/bugs:
 728  * None
 729  *
 730  * \par Sample code:
 731  * \code
 732  * ...
 733  *
 734  * int err = MSG_SUCCESS;
 735  * MSG_REQUEST_S req;
 736  *
 737  * req.msg = msg;
 738  * req.sendOpt = sendOpt;
 739  *
 740  * err = msg_mms_send_message(msgHandle, &req);
 741  * if (err != MSG_SUCCESS)
 742  * {
 743  * ...
 744  * }
 745  *
 746  * ...
 747  * \endcode
 748  */
 749 /*================================================================================================*/
 750 int msg_mms_send_message(msg_handle_t handle, msg_struct_t req);
 751
 752
 753 /**
 754
 755  * \par Description:
 756  * Submits request to send MMS read report request.
 757  *
 758  * \par Purpose:
 759  * This API is used to submit request to send MMS read report request.
 760  *
 761  * \par Typical use case:
 762  * Submits request to send MMS read report request.
 763  *
 764  * \par Method of function operation:
 765  * Submits a request to send MMS read report request.
 766  *
 767  * \par Sync (or) Async:
 768  * This is a Synchronous API.
 769  *
 770  * \par Important notes:
 771  * - None
 772  *
 773  * \param input  - handle is Message handle.
 774  * \param input  - msg_id is a message id, which is a positive integer.
 775  * \param input  - mms_read_status is status whether message was read or not.
 776  *
 777  * \return Return Type (int(msg_error_t)) \n
 778  * - MSG_SUCCESS                                Success in operation.
 779  * - MSG_ERR_NULL_POINTER               Invalid parameter.
 780  * - MSG_ERR_MEMORY_ERROR       Memory is error.
 781  *
 782  * \par Prospective clients:
 783  * External/Native Apps using Messaging Services.
 784  *
 785  * \par Related functions:
 786  * None
 787  *
 788  * \par Known issues/bugs:
 789  * None
 790  *
 791  * \par Sample code:
 792  * \code
 793  * ...
 794  *
 795  * int err = MSG_SUCCESS;
 796  *
 797  * err = err = msg_mms_send_read_report(NULL, 0, MSG_READ_REPORT_IS_READ);
 798  * if (err != MSG_SUCCESS)
 799  * {
 800  * ...
 801  * }
 802  *
 803  * ...
 804  * \endcode
 805  */
 806 /*================================================================================================*/
 807 int msg_mms_send_read_report(msg_handle_t handle, msg_message_id_t msgId, msg_read_report_status_t mms_read_status);
 808
 809
 810 /**
 811
 812  * \par Description:
 813  * Submits request to send forward MMS request.
 814  *
 815  * \par Purpose:
 816  * This API is used to submit request to send forward MMS request.
 817  *
 818  * \par Typical use case:
 819  * Submits request to send forward MMS request.
 820  *
 821  * \par Method of function operation:
 822  * Submits a request to send forward MMS request.
 823  *
 824  * \par Sync (or) Async:
 825  * This is a Synchronous API.
 826  *
 827  * \par Important notes:
 828  * - None
 829  *
 830  * \param input  - handle is Message handle.
 831   * \param input  - req is a pointer to an MSG_REQUEST_S structure.
 832  *
 833  * \return Return Type (int(msg_error_t)) \n
 834  * - MSG_SUCCESS                                        Success in operation.
 835  * - MSG_ERR_INVALID_MSGHANDLE          Message handle is invalid.
 836  * - MSG_ERR_NULL_POINTER                               Pointer is NULL.
 837  *
 838  * \par Prospective clients:
 839  * External/Native Apps using Messaging Services.
 840  *
 841  * \par Related functions:
 842  * None
 843  *
 844  * \par Known issues/bugs:
 845  * None
 846  *
 847  * \par Sample code:
 848  * \code
 849  * ...
 850  *
 851  * int err = MSG_SUCCESS;
 852  *
 853  * err = err = msg_mms_send_read_report(NULL, 0, MSG_READ_REPORT_IS_READ);
 854  * if (err != MSG_SUCCESS)
 855  * {
 856  * ...
 857  * }
 858  *
 859  * ...
 860  * \endcode
 861  */
 862 /*================================================================================================*/
 863 int msg_mms_forward_message(msg_handle_t handle, msg_struct_t req);
 864
 865
 866 /**
 867
 868  * \par Description:
 869  * Submits request to retrieve MMS request.
 870  *
 871  * \par Purpose:
 872  * This API is used to submit request to retrieve MMS request.
 873  *
 874  * \par Typical use case:
 875  * Submits request to retrieve MMS request.
 876  *
 877  * \par Method of function operation:
 878  * Submits a request to send forward MMS request.
 879  *
 880  * \par Sync (or) Async:
 881  * This is a Synchronous API.
 882  *
 883  * \par Important notes:
 884  * - None
 885  *
 886  * \param input  - handle is Message handle.
 887   * \param input  - req is a pointer to an MSG_REQUEST_S structure.
 888  *
 889  * \return Return Type (int(msg_error_t)) \n
 890  * - MSG_SUCCESS                                        Success in operation.
 891  * - MSG_ERR_INVALID_MSGHANDLE          Message handle is invalid.
 892  * - MSG_ERR_NULL_POINTER                               Pointer is NULL.
 893  *
 894  * \par Prospective clients:
 895  * External/Native Apps using Messaging Services.
 896  *
 897  * \par Related functions:
 898  * None
 899  *
 900  * \par Known issues/bugs:
 901  * None
 902  *
 903  * \par Sample code:
 904  * \code
 905  * ...
 906  *
 907  * int err = MSG_SUCCESS;
 908  *
 909  * err = msg_mms_retrieve_message(handle, &req);
 910  * if (err != MSG_SUCCESS)
 911  * {
 912  * ...
 913  * }
 914  *
 915  * ...
 916  * \endcode
 917  */
 918 /*================================================================================================*/
 919 int msg_mms_retrieve_message(msg_handle_t handle, msg_struct_t req);
 920
 921
 922 /* reject_msg_support */
 923 /**
 924
 925  * \par Description:
 926  * Submits request to reject MMS message.
 927  *
 928  * \par Purpose:
 929  * This API is used to submit request to reject MMS message.
 930  *
 931  * \par Typical use case:
 932  * Submits request to reject MMS message.
 933  *
 934  * \par Method of function operation:
 935  * Submits a request to send forward reject MMS message.
 936  *
 937  * \par Sync (or) Async:
 938  * This is a Synchronous API.
 939  *
 940  * \par Important notes:
 941  * - None
 942  *
 943  * \param input  - handle is Message handle.
 944   * \param input  - req is a pointer to an MSG_REQUEST_S structure.
 945  *
 946  * \return Return Type (int(msg_error_t)) \n
 947  * - MSG_SUCCESS                                        Success in operation.
 948  * - MSG_ERR_INVALID_MSGHANDLE          Message handle is invalid.
 949  * - MSG_ERR_NULL_POINTER                               Pointer is NULL.
 950  *
 951  * \par Prospective clients:
 952  * External/Native Apps using Messaging Services.
 953  *
 954  * \par Related functions:
 955  * None
 956  *
 957  * \par Known issues/bugs:
 958  * None
 959  *
 960  * \par Sample code:
 961  * \code
 962  * ...
 963  *
 964  * int err = MSG_SUCCESS;
 965  *
 966  * err = msg_mms_reject_message(handle, &req);
 967  * if (err != MSG_SUCCESS)
 968  * {
 969  * ...
 970  * }
 971  *
 972  * ...
 973  * \endcode
 974  */
 975 /*================================================================================================*/
 976 int msg_mms_reject_message(msg_handle_t handle, msg_struct_t req);
 977
 978 /**
 979  *      @}
 980  */
 981
 982 #ifdef __cplusplus
 983 }
 984 #endif
 985
 986 #endif // MAPI_TRANSPORT_H
 987