mapi/MapiMessage.cpp

   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 #include "MsgTypes.h"
  32 #include "MsgMmsTypes.h"
  33 #include "MsgMmsMessage.h"
  34 #include "MsgDebug.h"
  35 #include "MsgUtilFile.h"
  36 #include "MsgHandle.h"
  37 #include "MsgException.h"
  38 #include "MapiMessage.h"
  39 #include "MsgInternalTypes.h"
  40 #include "MsgDrmWrapper.h"
  41
  42
  43 static MSG_ERROR_T msg_mms_release_message(MMS_MESSAGE_DATA_S* msg_data);
  44
  45 /*==================================================================================================
  46                                      FUNCTION IMPLEMENTATION
  47 ==================================================================================================*/
  48 EXPORT_API msg_message_t msg_new_message(void)
  49 {
  50         MSG_MESSAGE_S *msg = new MSG_MESSAGE_S;
  51
  52         memset(msg, 0x00, sizeof(MSG_MESSAGE_S));
  53
  54         /* set default value to message*/
  55         msg->msgId = 0;
  56         msg->folderId = MSG_DRAFT_ID;
  57         msg->referenceId = 0;
  58         msg->msgType.mainType= MSG_SMS_TYPE;
  59         msg->msgType.subType = MSG_NORMAL_SMS;
  60         msg->msgType.classType = MSG_CLASS_NONE;
  61         msg->storageId = MSG_STORAGE_PHONE;
  62         msg->nAddressCnt = 0;
  63         time_t curTime = time(NULL);
  64         msg->displayTime = curTime;
  65         msg->networkStatus = MSG_NETWORK_NOT_SEND;
  66         msg->encodeType = MSG_ENCODE_AUTO;
  67         msg->bRead = false;
  68         msg->bProtected = false;
  69         msg->bBackup = false;
  70         msg->priority = MSG_MESSAGE_PRIORITY_NORMAL;
  71         msg->direction = MSG_DIRECTION_TYPE_MO;
  72         msg->msgPort.valid = false;
  73         msg->dataSize = 0;
  74         msg->pData = NULL;
  75         msg->pMmsData = NULL;
  76         msg->scheduledTime = 0;
  77
  78         return (msg_message_t) msg;
  79 }
  80
  81
  82 EXPORT_API int msg_release_message(msg_message_t *opq_msg)
  83 {
  84         if (opq_msg == NULL)
  85         {
  86                 MSG_FATAL("msg is NULL");
  87                 return MSG_ERR_NULL_POINTER;
  88         }
  89
  90         MSG_MESSAGE_S* msg = NULL;
  91
  92         msg = (MSG_MESSAGE_S*)(*opq_msg);
  93
  94         if (msg != NULL)
  95         {
  96                 MSG_DEBUG("main type : %d, data size : %d", msg->msgType.mainType, msg->dataSize);
  97
  98                 if (msg->pData)
  99                 {
 100                         delete [] static_cast<char*>(msg->pData);
 101                         msg->pData = NULL;
 102                 }
 103
 104                 if (msg->pMmsData)
 105                 {
 106                         delete [] static_cast<char*>(msg->pMmsData);
 107                         msg->pMmsData = NULL;
 108                 }
 109
 110                 delete (MSG_MESSAGE_S*)(*opq_msg);
 111                 *opq_msg = NULL;
 112         }
 113
 114         return MSG_SUCCESS;
 115 }
 116
 117
 118 EXPORT_API int msg_set_message_id(msg_message_t opq_msg, int msg_id)
 119 {
 120         if ( !opq_msg )
 121         {
 122                 MSG_FATAL("msg is NULL");
 123                 return MSG_ERR_NULL_POINTER;
 124         }
 125
 126         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 127         msg->msgId = msg_id;
 128         return MSG_SUCCESS;
 129 }
 130
 131
 132 EXPORT_API int msg_get_message_id(msg_message_t opq_msg)
 133 {
 134         if( !opq_msg )
 135         {
 136                 MSG_FATAL("msg is NULL");
 137                 return MSG_ERR_NULL_POINTER;
 138         }
 139         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 140
 141         return msg->msgId;
 142 }
 143
 144
 145 EXPORT_API int msg_set_message_type(msg_message_t opq_msg, MSG_MESSAGE_TYPE_T msg_type)
 146 {
 147         if (!opq_msg)
 148         {
 149                 MSG_FATAL("msg or text is NULL");
 150                 return MSG_ERR_NULL_POINTER;
 151         }
 152
 153         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*)opq_msg;
 154
 155         if (msg_type == MSG_TYPE_SMS)
 156         {
 157                 msg->msgType.mainType = MSG_SMS_TYPE;
 158                 msg->msgType.subType = MSG_NORMAL_SMS;
 159         }
 160         else if (msg_type == MSG_TYPE_MMS)
 161         {
 162                 msg->msgType.mainType = MSG_MMS_TYPE;
 163                 msg->msgType.subType = MSG_SENDREQ_MMS;
 164         }
 165         else if (msg_type == MSG_TYPE_MMS_JAVA)
 166         {
 167                 msg->msgType.mainType = MSG_MMS_TYPE;
 168                 msg->msgType.subType = MSG_SENDREQ_JAVA_MMS;
 169         }
 170         else if (msg_type == MSG_TYPE_SMS_SYNCML)
 171         {
 172                 msg->msgType.mainType = MSG_SMS_TYPE;
 173                 msg->msgType.subType = MSG_SYNCML_CP;
 174         }
 175         else if (msg_type == MSG_TYPE_SMS_REJECT)
 176         {
 177                 msg->msgType.mainType = MSG_SMS_TYPE;
 178                 msg->msgType.subType = MSG_REJECT_SMS;
 179         }
 180         else
 181         {
 182                 MSG_FATAL("invalid msg_type [%d]", msg_type);
 183                 return MSG_ERR_INVALID_PARAMETER;
 184         }
 185
 186         return MSG_SUCCESS;
 187 }
 188
 189
 190 EXPORT_API int msg_get_message_type(msg_message_t opq_msg)
 191 {
 192         if (!opq_msg)
 193         {
 194                 MSG_FATAL("msg or msg_type is NULL");
 195                 return MSG_ERR_NULL_POINTER;
 196         }
 197
 198         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*)opq_msg;
 199
 200         if (msg->msgType.mainType == MSG_SMS_TYPE)
 201         {
 202                 if (msg->msgType.subType == MSG_CB_SMS)
 203                         return MSG_TYPE_SMS_CB;
 204                 else    if (msg->msgType.subType == MSG_JAVACB_SMS)
 205                         return MSG_TYPE_SMS_JAVACB;
 206                 else    if (msg->msgType.subType == MSG_WAP_SI_SMS || msg->msgType.subType == MSG_WAP_SL_SMS)
 207                         return MSG_TYPE_SMS_WAPPUSH;
 208                 else    if (msg->msgType.subType == MSG_MWI_VOICE_SMS || msg->msgType.subType == MSG_MWI_FAX_SMS
 209                                 || msg->msgType.subType == MSG_MWI_EMAIL_SMS || msg->msgType.subType == MSG_MWI_OTHER_SMS)
 210                         return MSG_TYPE_SMS_MWI;
 211                 else    if (msg->msgType.subType == MSG_SYNCML_CP)
 212                         return MSG_TYPE_SMS_SYNCML;
 213                 else    if (msg->msgType.subType == MSG_REJECT_SMS)
 214                         return MSG_TYPE_SMS_REJECT;
 215                 else
 216                         return MSG_TYPE_SMS;
 217         }
 218         else if (msg->msgType.mainType == MSG_MMS_TYPE)
 219         {
 220                 if (msg->msgType.subType == MSG_NOTIFICATIONIND_MMS)
 221                         return MSG_TYPE_MMS_NOTI;
 222                 else if (msg->msgType.subType == MSG_SENDREQ_JAVA_MMS)
 223                         return MSG_TYPE_MMS_JAVA;
 224                 else
 225                         return MSG_TYPE_MMS;
 226         }
 227         else
 228                 return MSG_TYPE_INVALID;
 229 }
 230
 231
 232 EXPORT_API bool msg_is_sms(msg_message_t opq_msg)
 233 {
 234         if( !opq_msg )
 235         {
 236                 MSG_FATAL("msg or msg_type is NULL");
 237                 return false;
 238         }
 239
 240         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 241         return (msg->msgType.mainType == MSG_SMS_TYPE);
 242 }
 243
 244
 245 EXPORT_API bool msg_is_mms(msg_message_t opq_msg)
 246 {
 247         if( !opq_msg )
 248         {
 249                 MSG_FATAL("msg or msg_type is NULL");
 250                 return false;
 251         }
 252
 253         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 254         return (msg->msgType.mainType == MSG_MMS_TYPE);
 255 }
 256
 257
 258 EXPORT_API int msg_set_storage_id(msg_message_t opq_msg, MSG_STORAGE_ID_T storage_id)
 259 {
 260         if( !opq_msg)
 261         {
 262                 MSG_FATAL("msg or storage is NULL");
 263                 return MSG_ERR_NULL_POINTER;
 264         }
 265
 266         if (storage_id != MSG_STORAGE_PHONE && storage_id != MSG_STORAGE_SIM)
 267         {
 268                 MSG_FATAL("unsupported storage [%d]", storage_id);
 269                 return MSG_ERR_INVALID_PARAMETER;
 270         }
 271
 272         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 273
 274         msg->storageId = storage_id;
 275
 276         return MSG_SUCCESS;
 277 }
 278
 279
 280 EXPORT_API int msg_get_storage_id(msg_message_t opq_msg)
 281 {
 282         if( !opq_msg )
 283         {
 284                 MSG_FATAL("msg is NULL");
 285                 return MSG_ERR_NULL_POINTER;
 286         }
 287
 288         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 289
 290         return msg->storageId;
 291 }
 292
 293
 294 EXPORT_API bool msg_is_in_sim(msg_message_t opq_msg)
 295 {
 296         if( !opq_msg )
 297         {
 298                 MSG_FATAL("msg or folder is NULL");
 299                 return false;
 300         }
 301
 302         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 303
 304         return (msg->storageId == MSG_STORAGE_SIM);
 305 }
 306
 307
 308 EXPORT_API int msg_set_folder_id(msg_message_t opq_msg, MSG_FOLDER_ID_T folder_id)
 309 {
 310         if( !opq_msg)
 311         {
 312                 MSG_FATAL("msg or is NULL");
 313                 return MSG_ERR_NULL_POINTER;
 314         }
 315
 316         if (folder_id < MSG_INBOX_ID || folder_id > MSG_MAX_FOLDER_ID)
 317         {
 318                 MSG_FATAL("wrong folder ID [%d]", folder_id);
 319                 return MSG_ERR_INVALID_PARAMETER;
 320         }
 321
 322         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 323
 324         msg->folderId = folder_id;
 325
 326         return MSG_SUCCESS;
 327 }
 328
 329
 330 EXPORT_API int msg_get_folder_id(msg_message_t opq_msg)
 331 {
 332         if( !opq_msg )
 333         {
 334                 MSG_FATAL("msg is NULL");
 335                 return MSG_ERR_NULL_POINTER;
 336         }
 337
 338         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 339
 340         return msg->folderId;
 341 }
 342
 343
 344 EXPORT_API int msg_reset_address(msg_message_t opq_msg)
 345 {
 346         if( !opq_msg )
 347         {
 348                 MSG_FATAL("msg is NULL");
 349                 return MSG_ERR_NULL_POINTER;
 350         }
 351
 352         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 353
 354         msg->nAddressCnt = 0;
 355
 356         for (int i=0 ; i < MAX_TO_ADDRESS_CNT ; i++)
 357         {
 358                 msg->addressList[i].threadId = 0;
 359                 msg->addressList[i].addressType = MSG_ADDRESS_TYPE_UNKNOWN;
 360                 msg->addressList[i].recipientType = MSG_RECIPIENTS_TYPE_UNKNOWN;
 361                 msg->addressList[i].contactId = 0;
 362                 msg->addressList[i].addressVal[0] = '\0';
 363                 msg->addressList[i].displayName[0] = '\0';
 364         }
 365
 366         return MSG_SUCCESS;
 367 }
 368
 369
 370 EXPORT_API int msg_add_address(msg_message_t opq_msg, const char* phone_num_list, MSG_RECIPIENT_TYPE_T to_type )
 371 {
 372         if( !opq_msg || !phone_num_list)
 373         {
 374                 MSG_FATAL("msg or text or type is NULL");
 375                 return MSG_ERR_NULL_POINTER;
 376         }
 377
 378         if (to_type < MSG_RECIPIENTS_TYPE_TO || to_type > MSG_RECIPIENTS_TYPE_BCC)
 379         {
 380                 MSG_FATAL("unsupported recipient type [%d]", to_type);
 381                 return MSG_ERR_INVALID_PARAMETER;
 382         }
 383
 384         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 385
 386
 387         if(msg->msgType.mainType == MSG_SMS_TYPE)
 388         {
 389                 char trimmed_num[strlen(phone_num_list)+1];
 390                 bzero(trimmed_num, strlen(phone_num_list)+1);
 391
 392                 MSG_ERROR_T retVal = msg_verify_number(phone_num_list, trimmed_num);
 393
 394                 if ( retVal != MSG_SUCCESS )
 395                         return retVal;
 396
 397                 int i = msg->nAddressCnt;
 398                 for( char* cur_num = strtok(trimmed_num,", "); cur_num && (i < MAX_TO_ADDRESS_CNT);
 399                                                                                                                         cur_num = strtok(NULL,", "), i++)
 400                 {
 401                         if (strlen(cur_num) > MAX_ADDRESS_VAL_LEN)
 402                         {
 403                                 MSG_DEBUG("Phone number is too long [%s], and sending is skipped", cur_num);
 404                                 continue;
 405                         }
 406
 407                         /* fill the destination number in msgReq */
 408                         msg->nAddressCnt++;
 409                         msg->addressList[i].addressType = MSG_ADDRESS_TYPE_PLMN; // telephone number
 410                         msg->addressList[i].recipientType = to_type; // recipient type
 411                         snprintf(msg->addressList[i].addressVal, MAX_ADDRESS_VAL_LEN, "%s", cur_num);
 412                         MSG_DEBUG("SMS AddressVal = [%s]", msg->addressList[i].addressVal);
 413                 }
 414
 415         }
 416         else
 417         {
 418                 char phone_num_list_tmp[strlen(phone_num_list)+1];
 419                 bzero(phone_num_list_tmp, strlen(phone_num_list)+1);
 420
 421                 strncpy(phone_num_list_tmp, phone_num_list, strlen(phone_num_list));
 422
 423                 MSG_ERROR_T retVal = msg_verify_email(phone_num_list_tmp);
 424
 425                 if ( retVal != MSG_SUCCESS )
 426                         return retVal;
 427
 428                 int i = msg->nAddressCnt;
 429                 for( char* cur_num = strtok(phone_num_list_tmp,", "); cur_num && (i < MAX_TO_ADDRESS_CNT);
 430                                                                                                                         cur_num = strtok(NULL,", "), i++)
 431                 {
 432                         if (strlen(cur_num) > MAX_ADDRESS_VAL_LEN)
 433                         {
 434                                 MSG_DEBUG("Phone number is too long [%s], and sending is skipped", cur_num);
 435                                 continue;
 436                         }
 437
 438                         char trimmed_num[strlen(cur_num)+1];
 439                         bzero(trimmed_num, strlen(cur_num)+1);
 440
 441                         retVal = msg_verify_number(cur_num, trimmed_num);
 442
 443                         if(retVal == MSG_SUCCESS)
 444                         {
 445                                 /* fill the destination number in msgReq */
 446                                 msg->nAddressCnt++;
 447                                 msg->addressList[i].addressType = MSG_ADDRESS_TYPE_PLMN; // telephone number
 448                                 msg->addressList[i].recipientType = to_type; // recipient type
 449                                 snprintf(msg->addressList[i].addressVal, MAX_ADDRESS_VAL_LEN, "%s", trimmed_num);
 450                                 MSG_DEBUG("MMS Number AddressVal = [%s]", msg->addressList[i].addressVal);
 451                         }
 452                         else
 453                         {
 454                                 /* fill the destination number in msgReq */
 455                                 msg->nAddressCnt++;
 456                                 msg->addressList[i].addressType = MSG_ADDRESS_TYPE_EMAIL; // telephone number
 457                                 msg->addressList[i].recipientType = to_type; // recipient type
 458                                 snprintf(msg->addressList[i].addressVal, MAX_ADDRESS_VAL_LEN, "%s", cur_num);
 459                                 MSG_DEBUG("MMS Email AddressVal = [%s]", msg->addressList[i].addressVal);
 460                         }
 461                 }
 462         }
 463
 464         return MSG_SUCCESS;
 465 }
 466
 467
 468 EXPORT_API int msg_get_address_count(msg_message_t opq_msg)
 469 {
 470         if( !opq_msg )
 471         {
 472                 MSG_FATAL("msg or count is NULL");
 473                 return MSG_ERR_NULL_POINTER;
 474         }
 475         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 476         return msg->nAddressCnt;
 477 }
 478
 479
 480 EXPORT_API int msg_get_ith_thread_id(msg_message_t opq_msg, int ith)
 481 {
 482         if( !opq_msg)
 483         {
 484                 MSG_FATAL("msg or text or type is NULL");
 485                 return MSG_ERR_NULL_POINTER;
 486         }
 487
 488         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 489
 490         if( ith < msg->nAddressCnt )
 491         {
 492                 return msg->addressList[ith].threadId;
 493         }
 494         else
 495         {
 496                 MSG_FATAL("Requested address count %d exceeds max %d in msg", ith, msg->nAddressCnt);
 497                 return MSG_ERR_UNKNOWN;
 498         }
 499 }
 500
 501
 502 EXPORT_API const char* msg_get_ith_address(msg_message_t opq_msg, int ith)
 503 {
 504         if( !opq_msg )
 505         {
 506                 MSG_FATAL("msg or addr is NULL");
 507                 return NULL;
 508         }
 509
 510         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 511
 512         if( ith < msg->nAddressCnt )
 513         {
 514                 return msg->addressList[ith].addressVal;
 515         }
 516         else
 517         {
 518                 MSG_FATAL("Requested address count %d exceeds max %d in msg", ith, msg->nAddressCnt);
 519                 return NULL;
 520         }
 521 }
 522
 523
 524 EXPORT_API int msg_get_ith_recipient_type(msg_message_t opq_msg, int ith)
 525 {
 526         if( !opq_msg)
 527         {
 528                 MSG_FATAL("msg or text or type is NULL");
 529                 return MSG_ERR_NULL_POINTER;
 530         }
 531
 532         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 533
 534         if( ith < msg->nAddressCnt )
 535         {
 536                 return msg->addressList[ith].recipientType;
 537         }
 538         else
 539         {
 540                 MSG_FATAL("Requested address count %d exceeds max %d in msg", ith, msg->nAddressCnt);
 541                 return MSG_ERR_UNKNOWN;
 542         }
 543 }
 544
 545
 546 EXPORT_API const char* msg_get_ith_name(msg_message_t opq_msg, int ith)
 547 {
 548         if( !opq_msg )
 549         {
 550                 MSG_FATAL("msg or addr is NULL");
 551                 return NULL;
 552         }
 553
 554         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 555
 556         if( ith < msg->nAddressCnt )
 557         {
 558                 return msg->addressList[ith].displayName;
 559         }
 560         else
 561         {
 562                 MSG_FATAL("Requested address count %d exceeds max %d in msg", ith, msg->nAddressCnt);
 563                 return NULL;
 564         }
 565 }
 566
 567
 568 EXPORT_API int msg_get_ith_contact_id(msg_message_t opq_msg, int ith)
 569 {
 570         if( !opq_msg )
 571         {
 572                 MSG_FATAL("msg or addr is NULL");
 573                 return MSG_ERR_NULL_POINTER;
 574         }
 575
 576         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 577
 578         if( ith < msg->nAddressCnt )
 579         {
 580                 return msg->addressList[ith].contactId;
 581         }
 582         else
 583         {
 584                 MSG_FATAL("Requested address count %d exceeds max %d in msg", ith, msg->nAddressCnt);
 585                 return MSG_ERR_UNKNOWN;
 586         }
 587 }
 588
 589
 590 EXPORT_API int msg_set_reply_address(msg_message_t opq_msg, const char* phone_num)
 591 {
 592         if( !opq_msg || !phone_num)
 593         {
 594                 MSG_FATAL("msg or text or type is NULL");
 595                 return MSG_ERR_NULL_POINTER;
 596         }
 597
 598         if (strlen(phone_num) > MAX_PHONE_NUMBER_LEN)
 599         {
 600                 MSG_DEBUG("Phone number is too long [%s]", phone_num);
 601                 return MSG_ERR_INVALID_PARAMETER;
 602         }
 603
 604         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 605
 606         char trimmed_num[strlen(phone_num)+1];
 607         bzero(trimmed_num, strlen(phone_num)+1);
 608
 609         MSG_ERROR_T retVal = msg_verify_number(phone_num, trimmed_num);
 610
 611         if (retVal != MSG_SUCCESS)
 612                 return retVal;
 613
 614         snprintf(msg->replyAddress, MAX_PHONE_NUMBER_LEN, "%s", phone_num);
 615
 616         MSG_DEBUG("Reply Address Number : [%s]", msg->replyAddress);
 617
 618         return MSG_SUCCESS;
 619 }
 620
 621
 622 EXPORT_API int msg_sms_set_message_body(msg_message_t opq_msg, const char* mdata, int size)
 623 {
 624         if (!opq_msg || !mdata) {
 625                 MSG_FATAL("msg or text is NULL");
 626                 return MSG_ERR_NULL_POINTER;
 627         }
 628
 629         if (size <= 0) {
 630                 MSG_FATAL("msg size is invalid");
 631                 return MSG_ERR_INVALID_PARAMETER;
 632         }
 633
 634         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 635
 636         if(msg->msgType.mainType == MSG_MMS_TYPE) {
 637 /** Temporary added codes for Binary MMS. */
 638                 if (msg->pMmsData)
 639                         delete [] static_cast<char*>(msg->pMmsData);
 640
 641                 msg->dataSize = size;
 642
 643                 msg->pMmsData = (void*)new char[msg->dataSize+1];
 644
 645                 memset(msg->pMmsData, 0x00, msg->dataSize+1);
 646
 647                 memcpy((char *)msg->pMmsData, mdata, msg->dataSize);
 648
 649 /** End. */
 650         } else if (msg->msgType.mainType == MSG_SMS_TYPE) {
 651                 if (msg->pData)
 652                         delete [] static_cast<char*>(msg->pData);
 653
 654                 msg->dataSize = size;
 655
 656                 msg->pData = (void*)new char[msg->dataSize+1];
 657
 658                 memcpy((char *)msg->pData, mdata, msg->dataSize);
 659
 660                 ((char*) msg->pData)[msg->dataSize] = '\0';
 661
 662         } else {
 663                 return MSG_ERR_INVALID_MSG_TYPE;
 664         }
 665
 666         return MSG_SUCCESS;
 667
 668 }
 669
 670
 671 EXPORT_API const char* msg_sms_get_message_body(msg_message_t opq_msg)
 672 {
 673         if (!opq_msg) {
 674                 MSG_FATAL("msg is NULL");
 675                 return NULL;
 676         }
 677
 678         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 679
 680
 681         if (msg->msgType.mainType == MSG_SMS_TYPE) {
 682
 683                 return (char*) msg->pData;
 684
 685         } else if (msg->msgType.mainType == MSG_MMS_TYPE) {
 686
 687                 return (char*) msg->pMmsData;
 688
 689         } else {
 690                 MSG_FATAL("msg type is invalid.");
 691                 return NULL;
 692         }
 693
 694 }
 695
 696
 697 EXPORT_API const char* msg_mms_get_text_contents(msg_message_t opq_msg)
 698 {
 699         if( !opq_msg )
 700         {
 701                 MSG_FATAL("msg is NULL");
 702                 return NULL;
 703         }
 704
 705         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 706
 707         if(msg->msgType.mainType != MSG_MMS_TYPE)
 708         {
 709                 MSG_FATAL("msg is not mms type.");
 710                 return NULL;
 711         }
 712
 713         return (char*) msg->pData;
 714 }
 715
 716
 717 EXPORT_API int msg_get_message_body_size(msg_message_t opq_msg )
 718 {
 719         if( !opq_msg )
 720         {
 721                 MSG_FATAL("msg is NULL");
 722                 return MSG_ERR_NULL_POINTER;
 723         }
 724
 725         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 726         return msg->dataSize;
 727 }
 728
 729
 730 EXPORT_API int msg_set_subject(msg_message_t opq_msg, const char* subject )
 731 {
 732         if( !opq_msg || !subject )
 733         {
 734                 MSG_FATAL("msg or subject is NULL");
 735                 return MSG_ERR_NULL_POINTER;
 736         }
 737
 738         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 739
 740         snprintf(msg->subject, MAX_SUBJECT_LEN+1,"%s", subject);
 741
 742         return MSG_SUCCESS;
 743 }
 744
 745
 746 EXPORT_API const char* msg_get_subject(msg_message_t opq_msg)
 747 {
 748         if( !opq_msg )
 749         {
 750                 MSG_FATAL("msg is NULL");
 751                 return NULL;
 752         }
 753
 754         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 755
 756         return msg->subject;
 757 }
 758
 759
 760 EXPORT_API int msg_set_time(msg_message_t opq_msg, time_t msg_time)
 761 {
 762         if( !opq_msg )
 763         {
 764                 MSG_FATAL("msg is NULL");
 765                 return MSG_ERR_NULL_POINTER;
 766         }
 767
 768         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 769
 770         msg->displayTime = msg_time;
 771         return MSG_SUCCESS;
 772 }
 773
 774
 775 EXPORT_API time_t* msg_get_time(msg_message_t opq_msg)
 776 {
 777         if( !opq_msg )
 778         {
 779                 MSG_FATAL("msg is NULL");
 780                 return NULL;
 781         }
 782
 783         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 784
 785         return &(msg->displayTime);
 786 }
 787
 788 EXPORT_API int msg_set_network_status(msg_message_t opq_msg, MSG_NETWORK_STATUS_T status)
 789 {
 790         if( !opq_msg )
 791         {
 792                 MSG_FATAL("msg is NULL");
 793                 return MSG_ERR_NULL_POINTER;
 794         }
 795
 796         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 797         msg->networkStatus = status;
 798         return MSG_SUCCESS;
 799 }
 800
 801
 802 EXPORT_API int msg_get_network_status(msg_message_t opq_msg)
 803 {
 804         if( !opq_msg )
 805         {
 806                 MSG_FATAL("msg or status is NULL");
 807                 return MSG_ERR_NULL_POINTER;
 808         }
 809
 810         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 811         return msg->networkStatus;
 812 }
 813
 814
 815 EXPORT_API int msg_set_encode_type(msg_message_t opq_msg, MSG_ENCODE_TYPE_T encoding_type)
 816 {
 817         if( !opq_msg)
 818         {
 819                 MSG_FATAL("msg or encoding_type is NULL");
 820                 return MSG_ERR_NULL_POINTER;
 821         }
 822
 823         if( encoding_type != MSG_ENCODE_GSM7BIT &&
 824                 encoding_type != MSG_ENCODE_8BIT &&
 825                 encoding_type != MSG_ENCODE_UCS2 &&
 826                 encoding_type != MSG_ENCODE_AUTO )
 827         {
 828                 MSG_FATAL("Encoding_type has invalid value [%d]", encoding_type);
 829                 return MSG_ERR_INVALID_PARAMETER;
 830         }
 831
 832         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 833         msg->encodeType = encoding_type;
 834         return MSG_SUCCESS;
 835 }
 836
 837
 838 EXPORT_API int msg_get_encode_type(msg_message_t opq_msg)
 839 {
 840         if( !opq_msg )
 841         {
 842                 MSG_FATAL("msg is NULL");
 843                 return MSG_ERR_NULL_POINTER;
 844         }
 845
 846         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 847         return msg->encodeType;
 848 }
 849
 850
 851 EXPORT_API int msg_set_read_status(msg_message_t opq_msg, bool read_flag)
 852 {
 853         if( !opq_msg )
 854         {
 855                 MSG_FATAL("msg is NULL");
 856                 return MSG_ERR_NULL_POINTER;
 857         }
 858
 859         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 860         msg->bRead = read_flag;
 861         return MSG_SUCCESS;
 862 }
 863
 864
 865 EXPORT_API bool msg_is_read(msg_message_t opq_msg)
 866 {
 867         if( !opq_msg )
 868         {
 869                 MSG_FATAL("msg is NULL");
 870                 return false;
 871         }
 872
 873         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 874
 875         return msg->bRead;
 876 }
 877
 878
 879 EXPORT_API int msg_set_protect_status(msg_message_t opq_msg, bool protect_flag)
 880 {
 881         if( !opq_msg )
 882         {
 883                 MSG_FATAL("msg is NULL");
 884                 return MSG_ERR_NULL_POINTER;
 885         }
 886
 887         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 888         msg->bProtected = protect_flag;
 889         return MSG_SUCCESS;
 890 }
 891
 892
 893 EXPORT_API bool msg_is_protected(msg_message_t opq_msg)
 894 {
 895         if( !opq_msg )
 896         {
 897                 MSG_FATAL("msg or protected is NULL");
 898                 return false;
 899         }
 900
 901         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 902         return msg->bProtected;
 903 }
 904
 905
 906 EXPORT_API int msg_set_backup_status(msg_message_t opq_msg, bool backup_flag)
 907 {
 908         if( !opq_msg )
 909         {
 910                 MSG_FATAL("msg is NULL");
 911                 return MSG_ERR_NULL_POINTER;
 912         }
 913
 914         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 915         msg->bBackup = backup_flag;
 916         return MSG_SUCCESS;
 917 }
 918
 919
 920 EXPORT_API bool msg_is_backup(msg_message_t opq_msg)
 921 {
 922         if( !opq_msg )
 923         {
 924                 MSG_FATAL("msg or protected is NULL");
 925                 return false;
 926         }
 927
 928         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 929         return msg->bBackup;
 930 }
 931
 932
 933 EXPORT_API int msg_set_priority_info(msg_message_t opq_msg, MSG_PRIORITY_TYPE_T priority)
 934 {
 935         if( !opq_msg)
 936         {
 937                 MSG_FATAL("msg is NULL");
 938                 return MSG_ERR_NULL_POINTER;
 939         }
 940
 941         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 942         msg->priority = priority;
 943         return MSG_SUCCESS;
 944 }
 945
 946
 947 EXPORT_API int msg_get_priority_info(msg_message_t opq_msg)
 948 {
 949         if( !opq_msg)
 950         {
 951                 MSG_FATAL("msg is NULL");
 952                 return MSG_ERR_NULL_POINTER;
 953         }
 954
 955         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 956         return msg->priority;
 957 }
 958
 959
 960 EXPORT_API int msg_set_direction_info(msg_message_t opq_msg, MSG_DIRECTION_TYPE_T direction)
 961 {
 962         if( !opq_msg)
 963         {
 964                 MSG_FATAL("msg is NULL");
 965                 return MSG_ERR_NULL_POINTER;
 966         }
 967
 968         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 969         msg->direction= direction;
 970         return MSG_SUCCESS;
 971 }
 972
 973
 974 EXPORT_API int msg_get_direction_info(msg_message_t opq_msg)
 975 {
 976         if( !opq_msg )
 977         {
 978                 MSG_FATAL("msg is NULL");
 979                 return MSG_ERR_NULL_POINTER;
 980         }
 981
 982         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 983         return msg->direction;
 984 }
 985
 986
 987 EXPORT_API int msg_set_port(msg_message_t opq_msg, unsigned short dst_port, unsigned short src_port)
 988 {
 989         if( !opq_msg )
 990         {
 991                 MSG_FATAL("msg is NULL");
 992                 return MSG_ERR_NULL_POINTER;
 993         }
 994
 995         if( !dst_port && !src_port )
 996                 return MSG_SUCCESS;
 997
 998         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
 999         msg->msgPort.valid = true;
1000         msg->msgPort.dstPort = dst_port;
1001         msg->msgPort.srcPort = src_port;
1002
1003         return MSG_SUCCESS;
1004 }
1005
1006
1007 EXPORT_API int msg_get_dest_port(msg_message_t opq_msg)
1008 {
1009         if( !opq_msg )
1010         {
1011                 MSG_FATAL("msg or dst_port or src_port is NULL");
1012                 return MSG_ERR_NULL_POINTER;
1013         }
1014
1015         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
1016         if( msg->msgPort.valid )
1017                 return msg->msgPort.dstPort;
1018         else
1019                 return 0;
1020 }
1021
1022
1023 EXPORT_API int msg_get_src_port(msg_message_t opq_msg)
1024 {
1025         if( !opq_msg )
1026         {
1027                 MSG_FATAL("msg or dst_port or src_port is NULL");
1028                 return MSG_ERR_NULL_POINTER;
1029         }
1030
1031         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
1032         if( msg->msgPort.valid )
1033                 return msg->msgPort.srcPort;
1034         else
1035                 return 0;
1036 }
1037
1038
1039 EXPORT_API int msg_set_scheduled_time(msg_message_t opq_msg, time_t time_to_send)
1040 {
1041         if( !opq_msg )
1042         {
1043                 MSG_FATAL("msg is NULL");
1044                 return MSG_ERR_NULL_POINTER;
1045         }
1046
1047         if( !time_to_send )
1048                 return MSG_SUCCESS;
1049
1050         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
1051         msg->scheduledTime = time_to_send;
1052
1053         return MSG_SUCCESS;
1054 }
1055
1056
1057 EXPORT_API time_t* msg_get_scheduled_time(msg_message_t opq_msg)
1058 {
1059         if( !opq_msg )
1060         {
1061                 MSG_FATAL("msg is NULL");
1062                 return NULL;
1063         }
1064
1065         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
1066         return &(msg->scheduledTime);
1067 }
1068
1069
1070 EXPORT_API int msg_get_attachment_count(msg_message_t opq_msg)
1071 {
1072         if ( !opq_msg )
1073         {
1074                 MSG_FATAL("msg is NULL");
1075                 return MSG_ERR_NULL_POINTER;
1076         }
1077
1078         MSG_MESSAGE_S* msg = (MSG_MESSAGE_S*) opq_msg;
1079
1080         return msg->attachCount;
1081 }
1082
1083 EXPORT_API const char* msg_get_thumbnail_path(msg_message_t opq_msg)
1084 {
1085         if (!opq_msg)
1086         {
1087                 MSG_FATAL("msg is NULL");
1088                 return NULL;
1089         }
1090
1091         MSG_MESSAGE_S* pMsg = (MSG_MESSAGE_S*)opq_msg;
1092
1093         return pMsg->thumbPath;
1094 }
1095
1096
1097 static MSG_ERROR_T msg_mms_release_message(MMS_MESSAGE_DATA_S* msg_data)
1098 {
1099         _MsgMmsReleasePageList(msg_data);
1100         _MsgMmsReleaseRegionList(msg_data);
1101         _MsgMmsReleaseAttachList(msg_data);
1102         _MsgMmsReleaseTransitionList(msg_data);
1103         _MsgMmsReleaseMetaList(msg_data);
1104         return MSG_SUCCESS;
1105 }
1106
1107
1108 EXPORT_API int msg_mms_set_message_body(msg_message_t opq_msg, const MMS_MESSAGE_DATA_S *msg_data)
1109 {
1110         if (!opq_msg || !msg_data) {
1111                 MSG_FATAL("msg or msg_data is NULL");
1112                 return MSG_ERR_NULL_POINTER;
1113         }
1114
1115         MSG_MESSAGE_S* msg = (MSG_MESSAGE_S*) opq_msg;
1116
1117         if (msg->msgType.mainType != MSG_MMS_TYPE) {
1118                 MSG_FATAL("msg is not mms type.");
1119                 return MSG_ERR_INVALID_MSG_TYPE;
1120         }
1121
1122         if (msg->pMmsData) {
1123                 if (msg->dataSize > 0)
1124                         delete[] ((char*) msg->pMmsData);
1125         }
1126
1127         msg->dataSize = 0;
1128
1129         msg->pMmsData = _MsgMmsSerializeMessageData(msg_data, &(msg->dataSize));
1130
1131         MSG_DEBUG("msg->dataSize : [%d]", msg->dataSize);
1132
1133         if (msg->dataSize <= 0) {
1134                 MSG_FATAL("msg size is invalid");
1135                 return MSG_ERR_INVALID_PARAMETER;
1136         }
1137
1138         return MSG_SUCCESS;
1139 }
1140
1141
1142 EXPORT_API int msg_mms_get_message_body(msg_message_t opq_msg, MMS_MESSAGE_DATA_S *body )
1143 {
1144         if (!opq_msg || !body) {
1145                 MSG_FATAL("msg or body is NULL");
1146                 return MSG_ERR_NULL_POINTER;
1147         }
1148
1149         MSG_MESSAGE_S *msg = (MSG_MESSAGE_S*) opq_msg;
1150
1151         if (msg->msgType.mainType != MSG_MMS_TYPE) {
1152                 MSG_FATAL("msg is not mms type.");
1153                 return MSG_ERR_INVALID_MSG_TYPE;
1154         }
1155
1156         if (msg->pMmsData == NULL) {
1157                 MSG_FATAL("msg->pMmsData is NULL");
1158                 return MSG_ERR_NULL_POINTER;
1159         }
1160
1161         _MsgMmsDeserializeMessageData(body, (char*)msg->pMmsData);
1162
1163         return MSG_SUCCESS;
1164 }
1165
1166
1167 EXPORT_API MMS_PAGE_S* msg_mms_add_page(MMS_MESSAGE_DATA_S *msg_data, const int duration)
1168 {
1169         if(msg_data == NULL)
1170                 return NULL;
1171
1172         MMS_PAGE_S* page = (MMS_PAGE_S*)calloc(sizeof(MMS_PAGE_S), 1);
1173         page->nDur = duration;
1174
1175         _MsgMmsAddPage(msg_data, page);
1176
1177         return page;
1178 }
1179
1180
1181 EXPORT_API MMS_SMIL_REGION* msg_mms_add_region(MMS_MESSAGE_DATA_S *msg_data, const char* szID, const int x, const int y, const int width, const int height, const int bgcolor)
1182 {
1183         if(msg_data == NULL || szID == NULL)
1184                 return NULL;
1185
1186         MMS_SMIL_REGION* region = (MMS_SMIL_REGION *)calloc( sizeof(MMS_SMIL_REGION), 1 );
1187
1188         strncpy(region->szID, szID, MAX_SMIL_REGION_ID-1);
1189         region->bgColor = bgcolor;
1190         region->nLeft.value = x;
1191         region->nLeft.bUnitPercent = true;
1192         region->nTop.value = y;
1193         region->nTop.bUnitPercent = true;
1194         region->width.value = width;
1195         region->width.bUnitPercent = true;
1196         region->height.value = height;
1197         region->height.bUnitPercent = true;
1198         region->fit = MMSUI_IMAGE_REGION_FIT_MEET;
1199
1200         _MsgMmsAddRegion(msg_data, region);
1201
1202         return region;
1203 }
1204
1205
1206 EXPORT_API MMS_MEDIA_S* msg_mms_add_media(MMS_PAGE_S *page, const MmsSmilMediaType mediatype, const char* regionid, char* filepath)
1207 {
1208         if(page == NULL || filepath == NULL)
1209                 return NULL;
1210
1211         if (MsgDrmIsDrmFile(filepath)) {
1212                 MSG_DRM_TYPE drm_type = MSG_DRM_NONE;
1213
1214                 if (MsgDrmGetDrmType(filepath, &drm_type)) {
1215                         if (drm_type == MSG_DRM_FORWARD_LOCK || drm_type == MSG_DRM_COMBINED_DELIVERY) {
1216                                 MSG_FATAL("file is a FL content");
1217                                 return NULL;
1218                         }
1219                 }
1220         }
1221
1222         MMS_MEDIA_S* media = (MMS_MEDIA_S *)calloc(sizeof(MMS_MEDIA_S), 1);
1223         char *filename = NULL;
1224
1225         media->mediatype = mediatype;
1226
1227         if(regionid)
1228                 strncpy(media->regionId, regionid, MAX_SMIL_REGION_ID-1);
1229
1230         strncpy(media->szFilePath, filepath, MSG_FILEPATH_LEN_MAX-1);
1231
1232         filename = strrchr(filepath, '/');
1233         strncpy(media->szFileName, filename + 1, MSG_FILENAME_LEN_MAX-1);
1234         strncpy(media->szContentID, filename + 1, MSG_MSG_ID_LEN);
1235
1236         _MsgMmsAddMedia(page, media);
1237
1238         return media;
1239 }
1240
1241
1242 EXPORT_API MMS_ATTACH_S* msg_mms_add_attachment(MMS_MESSAGE_DATA_S *msg_data, char *filepath)
1243 {
1244         if(msg_data == NULL || filepath == NULL)
1245                 return NULL;
1246
1247         if (MsgDrmIsDrmFile(filepath)) {
1248                 MSG_DRM_TYPE drm_type = MSG_DRM_NONE;
1249
1250                 if (MsgDrmGetDrmType(filepath, &drm_type)) {
1251                         if (drm_type == MSG_DRM_FORWARD_LOCK || drm_type == MSG_DRM_COMBINED_DELIVERY) {
1252                                 MSG_FATAL("file is a FL content");
1253                                 return NULL;
1254                         }
1255                 }
1256         }
1257
1258         MMS_ATTACH_S* attach = (MMS_ATTACH_S*)calloc(sizeof(MMS_ATTACH_S), 1);
1259         char *filename = NULL;
1260
1261         attach->mediatype = MIME_UNKNOWN;
1262         attach->fileSize = -1;
1263         strncpy(attach->szFilePath, filepath, MSG_FILEPATH_LEN_MAX-1);
1264         filename = strrchr(filepath, '/');
1265         strncpy(attach->szFileName, filename + 1, MSG_FILENAME_LEN_MAX-1);
1266
1267         _MsgMmsAddAttachment(msg_data, attach);
1268
1269         return attach;
1270 }
1271
1272
1273 EXPORT_API int msg_mms_add_transition(MMS_MESSAGE_DATA_S *msg_data, MMS_SMIL_TRANSITION *transition)
1274 {
1275         if(msg_data == NULL || transition == NULL)
1276                 return MSG_ERR_NULL_POINTER;
1277
1278         MMS_SMIL_TRANSITION *pTransition = (MMS_SMIL_TRANSITION *)calloc(sizeof(MMS_SMIL_TRANSITION), 1);
1279
1280         if (transition->szID[0] != '0')
1281                 strncpy(pTransition->szID, transition->szID, MAX_SMIL_TRANSITION_ID);
1282
1283         pTransition->nType = transition->nType;
1284         pTransition->nSubType = transition->nSubType;
1285         pTransition->nDur = transition->nDur;
1286
1287         _MsgMmsAddTransition(msg_data, pTransition);
1288
1289         return MSG_SUCCESS;
1290 }
1291
1292
1293 EXPORT_API int msg_mms_add_meta(MMS_MESSAGE_DATA_S *msg_data, MMS_SMIL_META *meta)
1294 {
1295         if(msg_data == NULL || meta == NULL)
1296                 return MSG_ERR_NULL_POINTER;
1297
1298         MMS_SMIL_META *pMeta = (MMS_SMIL_META *)calloc(sizeof(MMS_SMIL_META), 1);
1299
1300         if (meta->szID[0] != '0')
1301                 strncpy(pMeta->szID, meta->szID, MAX_SMIL_TRANSITION_ID);
1302
1303         if (meta->szName[0] != '0')
1304                 strncpy(pMeta->szName, meta->szName, MAX_SMIL_META_NAME);
1305
1306         if (meta->szContent[0] != '0')
1307                 strncpy(pMeta->szContent, meta->szContent, MAX_SMIL_META_NAME);
1308
1309         _MsgMmsAddMeta(msg_data, pMeta);
1310
1311         return MSG_SUCCESS;
1312 }
1313
1314
1315 EXPORT_API MMS_PAGE_S *msg_mms_get_page(MMS_MESSAGE_DATA_S *msg_data, int page_idx)
1316 {
1317         if (msg_data == NULL)
1318                 return NULL;
1319
1320         if (page_idx < 0)
1321                 return NULL;
1322
1323         return _MsgMmsGetPage(msg_data, page_idx);
1324 }
1325
1326
1327 EXPORT_API MMS_SMIL_REGION* msg_mms_get_smil_region(MMS_MESSAGE_DATA_S *msg_data, int region_idx)
1328 {
1329         if (msg_data == NULL)
1330                 return NULL;
1331
1332         if (region_idx < 0)
1333                 return NULL;
1334
1335         return _MsgMmsGetSmilRegion(msg_data, region_idx);
1336 }
1337
1338
1339 EXPORT_API MMS_MEDIA_S* msg_mms_get_media(MMS_PAGE_S *page, int media_idx)
1340 {
1341         if (page == NULL || media_idx < 0)
1342                 return NULL;
1343
1344         return _MsgMmsGetMedia(page, media_idx);
1345 }
1346
1347
1348 EXPORT_API MMS_ATTACH_S* msg_mms_get_attachment(MMS_MESSAGE_DATA_S *msg_data, int attach_idx)
1349 {
1350         if (msg_data == NULL)
1351                 return NULL;
1352
1353         if ( attach_idx <0 )
1354                 return NULL;
1355
1356         return _MsgMmsGetAttachment(msg_data, attach_idx);
1357 }
1358
1359
1360 EXPORT_API MMS_SMIL_TRANSITION* msg_mms_get_transition(MMS_MESSAGE_DATA_S *msg_data, int transition_idx)
1361 {
1362         if (msg_data == NULL)
1363                 return NULL;
1364
1365         if (transition_idx < 0)
1366                 return NULL;
1367
1368         return _MsgMmsGetTransition(msg_data, transition_idx);
1369 }
1370
1371
1372 EXPORT_API MMS_SMIL_META* msg_mms_get_meta(MMS_MESSAGE_DATA_S *msg_data, int meta_idx)
1373 {
1374         if (msg_data == NULL)
1375                 return NULL;
1376
1377         if (meta_idx < 0)
1378                 return NULL;
1379
1380         return _MsgMmsGetMeta(msg_data, meta_idx);
1381 }
1382
1383
1384 EXPORT_API int msg_mms_release_page_list(MMS_MESSAGE_DATA_S *msg_data)
1385 {
1386         if (msg_data == NULL)
1387                 return MSG_ERR_NULL_POINTER;
1388
1389         MSG_ERROR_T err = MSG_SUCCESS;
1390
1391         err = _MsgMmsReleasePageList(msg_data);
1392
1393         return err;
1394 }
1395
1396
1397 EXPORT_API int msg_mms_release_region_list(MMS_MESSAGE_DATA_S *msg_data)
1398 {
1399         if (msg_data == NULL)
1400                 return MSG_ERR_NULL_POINTER;
1401
1402         MSG_ERROR_T err = MSG_SUCCESS;
1403
1404         err = _MsgMmsReleaseRegionList(msg_data);
1405
1406         return err;
1407 }
1408
1409
1410 EXPORT_API int msg_mms_release_attachment_list(MMS_MESSAGE_DATA_S *msg_data)
1411 {
1412         if (msg_data == NULL)
1413                 return MSG_ERR_NULL_POINTER;
1414
1415         MSG_ERROR_T err = MSG_SUCCESS;
1416
1417         err = _MsgMmsReleaseAttachList(msg_data);
1418
1419         return err;
1420 }
1421
1422
1423 EXPORT_API int msg_mms_release_transition_list(MMS_MESSAGE_DATA_S *msg_data)
1424 {
1425         if (msg_data == NULL)
1426                 return MSG_ERR_NULL_POINTER;
1427
1428         MSG_ERROR_T err = MSG_SUCCESS;
1429
1430         err = _MsgMmsReleaseTransitionList(msg_data);
1431
1432         return err;
1433 }
1434
1435
1436 EXPORT_API int msg_mms_release_meta_list(MMS_MESSAGE_DATA_S *msg_data)
1437 {
1438         if (msg_data == NULL)
1439                 return MSG_ERR_NULL_POINTER;
1440
1441         MSG_ERROR_T err = MSG_SUCCESS;
1442
1443         err = _MsgMmsReleaseMetaList(msg_data);
1444
1445         return err;
1446 }
1447
1448
1449 EXPORT_API MMS_MESSAGE_DATA_S* msg_mms_create_message(void)
1450 {
1451         MMS_MESSAGE_DATA_S *mmsmsg = (MMS_MESSAGE_DATA_S *)calloc(sizeof(MMS_MESSAGE_DATA_S), 1);
1452
1453         return mmsmsg;
1454 }
1455
1456
1457 EXPORT_API MMS_SMIL_ROOTLAYOUT* msg_mms_set_rootlayout(MMS_MESSAGE_DATA_S* msg, const int width, const int height, const int bgcolor)
1458 {
1459         if (msg == NULL)
1460                 return NULL;
1461
1462         msg->rootlayout.width.value = width;
1463         msg->rootlayout.width.bUnitPercent = true;
1464         msg->rootlayout.height.value = height;
1465         msg->rootlayout.height.bUnitPercent = true;
1466         msg->rootlayout.bgColor = bgcolor;
1467
1468         return (MMS_SMIL_ROOTLAYOUT *)&(msg->rootlayout);
1469 }
1470
1471
1472 EXPORT_API int msg_mms_destroy_message(MMS_MESSAGE_DATA_S* msg)
1473 {
1474         if (msg == NULL)
1475                 return MSG_ERR_NULL_POINTER;
1476
1477         msg_mms_release_message(msg);
1478
1479         free(msg);
1480
1481         msg = NULL;
1482
1483         return MSG_SUCCESS;
1484 }
1485