include/mapi/MapiTransport.h

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