mapi/msg_storage.cpp

   1 /*
   2 * Copyright 2012  Samsung Electronics Co., Ltd
   3 *
   4 * Licensed under the Flora License, Version 1.0 (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://www.tizenopensource.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 #include <errno.h>
  18
  19 #include "MsgHandle.h"
  20 #include "MsgDebug.h"
  21 #include "MsgException.h"
  22
  23 #include "msg.h"
  24 #include "msg_private.h"
  25 #include "msg_storage.h"
  26
  27
  28 static int msg_thread_get_msg_type(int mainType, int subType);
  29 /*==================================================================================================
  30                                      FUNCTION IMPLEMENTATION
  31 ==================================================================================================*/
  32 EXPORT_API int msg_add_message(msg_handle_t handle, msg_struct_t opq_msg, const msg_struct_t send_opt)
  33 {
  34         msg_error_t err =  MSG_SUCCESS;
  35
  36         if (handle == NULL || opq_msg == NULL || send_opt == NULL)
  37         {
  38                 return -EINVAL;
  39         }
  40
  41         MsgHandle* pHandle = (MsgHandle*)handle;
  42
  43         msg_struct_s *pMsgStruct = (msg_struct_s *)opq_msg;
  44         msg_struct_s *pStruct = (msg_struct_s *)send_opt;
  45
  46         try
  47         {
  48                 err = pHandle->addMessage((MSG_MESSAGE_HIDDEN_S *)pMsgStruct->data, (MSG_SENDINGOPT_S *)pStruct->data);
  49         }
  50         catch (MsgException& e)
  51         {
  52                 MSG_FATAL("%s", e.what());
  53                 return MSG_ERR_STORAGE_ERROR;
  54         }
  55
  56         return err;
  57 }
  58
  59
  60 EXPORT_API int msg_add_syncml_message(msg_handle_t handle, const msg_struct_t syncml_msg)
  61 {
  62         msg_error_t err =  MSG_SUCCESS;
  63
  64         if (handle == NULL || syncml_msg == NULL)
  65         {
  66                 return -EINVAL;
  67         }
  68
  69         MsgHandle* pHandle = (MsgHandle*)handle;
  70         msg_struct_s *pStruct = (msg_struct_s *)syncml_msg;
  71
  72         try
  73         {
  74                 err = pHandle->addSyncMLMessage((MSG_SYNCML_MESSAGE_S *)pStruct->data);
  75         }
  76         catch (MsgException& e)
  77         {
  78                 MSG_FATAL("%s", e.what());
  79                 return MSG_ERR_STORAGE_ERROR;
  80         }
  81
  82         return err;
  83 }
  84
  85
  86 EXPORT_API int msg_update_message(msg_handle_t handle, const msg_struct_t opq_msg, const msg_struct_t send_opt)
  87 {
  88         msg_error_t err =  MSG_SUCCESS;
  89
  90         if (handle == NULL || opq_msg == NULL || send_opt == NULL)
  91         {
  92                 return -EINVAL;
  93         }
  94
  95         MsgHandle* pHandle = (MsgHandle*)handle;
  96         msg_struct_s *pMsgStruct = (msg_struct_s *)opq_msg;
  97         msg_struct_s* pStruct = (msg_struct_s *)send_opt;
  98
  99         MSG_MESSAGE_HIDDEN_S *msg = (MSG_MESSAGE_HIDDEN_S *)pMsgStruct->data;
 100
 101         if (msg->addr_list->nCount > 1)
 102         {
 103                 MSG_DEBUG("Multiple Address cannot be updated [%d]", msg->addr_list->nCount);
 104                 return -EINVAL;
 105         }
 106
 107         try
 108         {
 109                 err = pHandle->updateMessage(msg, (MSG_SENDINGOPT_S *)pStruct->data);
 110         }
 111         catch (MsgException& e)
 112         {
 113                 MSG_FATAL("%s", e.what());
 114                 return MSG_ERR_STORAGE_ERROR;
 115         }
 116
 117         return err;
 118 }
 119
 120
 121 EXPORT_API int msg_update_read_status(msg_handle_t handle, msg_message_id_t msg_id, bool read)
 122 {
 123         msg_error_t err =  MSG_SUCCESS;
 124
 125         if (handle == NULL)
 126         {
 127                 return -EINVAL;
 128         }
 129
 130         MsgHandle* pHandle = (MsgHandle*)handle;
 131
 132         try
 133         {
 134                 err = pHandle->updateReadStatus(msg_id, read);
 135         }
 136         catch (MsgException& e)
 137         {
 138                 MSG_FATAL("%s", e.what());
 139                 return MSG_ERR_STORAGE_ERROR;
 140         }
 141
 142         return err;
 143 }
 144
 145
 146 EXPORT_API int msg_update_protected_status(msg_handle_t handle, msg_message_id_t msg_id, bool is_protected)
 147 {
 148         msg_error_t err =  MSG_SUCCESS;
 149
 150         if (handle == NULL)
 151         {
 152                 return -EINVAL;
 153         }
 154
 155         MsgHandle* pHandle = (MsgHandle*)handle;
 156
 157         try
 158         {
 159                 err = pHandle->updateProtectedStatus(msg_id, is_protected);
 160         }
 161         catch (MsgException& e)
 162         {
 163                 MSG_FATAL("%s", e.what());
 164                 return MSG_ERR_STORAGE_ERROR;
 165         }
 166
 167         return err;
 168 }
 169
 170
 171 EXPORT_API int msg_delete_message(msg_handle_t handle, msg_message_id_t msg_id)
 172 {
 173         msg_error_t err =  MSG_SUCCESS;
 174
 175         if (handle == NULL)
 176         {
 177                 return -EINVAL;
 178         }
 179
 180         MsgHandle* pHandle = (MsgHandle*)handle;
 181
 182         try
 183         {
 184                 err = pHandle->deleteMessage(msg_id);
 185         }
 186         catch (MsgException& e)
 187         {
 188                 MSG_FATAL("%s", e.what());
 189                 return MSG_ERR_STORAGE_ERROR;
 190         }
 191
 192         return err;
 193 }
 194
 195
 196 EXPORT_API int msg_delete_all_msgs_in_folder(msg_handle_t handle, msg_folder_id_t folder_id, bool bOnlyDB)
 197 {
 198         msg_error_t err =  MSG_SUCCESS;
 199
 200         if (handle == NULL)
 201         {
 202                 return -EINVAL;
 203         }
 204
 205         MsgHandle* pHandle = (MsgHandle*)handle;
 206
 207         try
 208         {
 209                 err = pHandle->deleteAllMessagesInFolder(folder_id, bOnlyDB);
 210         }
 211         catch (MsgException& e)
 212         {
 213                 MSG_FATAL("%s", e.what());
 214                 return MSG_ERR_STORAGE_ERROR;
 215         }
 216
 217         return err;
 218 }
 219
 220
 221 EXPORT_API int msg_move_msg_to_folder(msg_handle_t handle, msg_message_id_t msg_id, msg_folder_id_t dest_folder_id)
 222 {
 223         msg_error_t err =  MSG_SUCCESS;
 224
 225         if (handle == NULL)
 226         {
 227                 return -EINVAL;
 228         }
 229
 230         MsgHandle* pHandle = (MsgHandle*)handle;
 231
 232         try
 233         {
 234                 err = pHandle->moveMessageToFolder(msg_id, dest_folder_id);
 235         }
 236         catch (MsgException& e)
 237         {
 238                 MSG_FATAL("%s", e.what());
 239                 return MSG_ERR_STORAGE_ERROR;
 240         }
 241
 242         return err;
 243 }
 244
 245
 246 EXPORT_API int msg_move_msg_to_storage(msg_handle_t handle, msg_message_id_t msg_id, msg_storage_id_t storage_id)
 247 {
 248         msg_error_t err =  MSG_SUCCESS;
 249
 250         if (handle == NULL)
 251         {
 252                 return -EINVAL;
 253         }
 254
 255         if (storage_id != MSG_STORAGE_PHONE && storage_id != MSG_STORAGE_SIM)
 256         {
 257                 MSG_FATAL("unsupported storage [%d]", storage_id);
 258                 return MSG_ERR_INVALID_PARAMETER;
 259         }
 260
 261         MsgHandle* pHandle = (MsgHandle*)handle;
 262
 263         try
 264         {
 265                 err = pHandle->moveMessageToStorage(msg_id, storage_id);
 266         }
 267         catch (MsgException& e)
 268         {
 269                 MSG_FATAL("%s", e.what());
 270                 return MSG_ERR_STORAGE_ERROR;
 271         }
 272
 273         return err;
 274 }
 275
 276
 277 EXPORT_API int msg_count_message(msg_handle_t handle, msg_folder_id_t folder_id, msg_struct_t count_info)
 278 {
 279         msg_error_t err =  MSG_SUCCESS;
 280
 281         if (handle == NULL)
 282         {
 283                 return -EINVAL;
 284         }
 285
 286         MsgHandle* pHandle = (MsgHandle*)handle;
 287         msg_struct_s *pStruct = (msg_struct_s *)count_info;
 288         try
 289         {
 290                 err = pHandle->countMessage(folder_id, (MSG_COUNT_INFO_S *)pStruct->data);
 291         }
 292         catch (MsgException& e)
 293         {
 294                 MSG_FATAL("%s", e.what());
 295                 return MSG_ERR_STORAGE_ERROR;
 296         }
 297
 298         return err;
 299 }
 300
 301
 302 EXPORT_API int msg_count_msg_by_type(msg_handle_t handle, msg_message_type_t msg_type, int *msg_count)
 303 {
 304         msg_error_t err =  MSG_SUCCESS;
 305
 306         if (handle == NULL)
 307         {
 308                 return -EINVAL;
 309         }
 310
 311         MsgHandle* pHandle = (MsgHandle*)handle;
 312
 313         MSG_MESSAGE_TYPE_S msgType = {0};
 314
 315         if (msg_type == MSG_TYPE_SMS)
 316         {
 317                 msgType.mainType = MSG_SMS_TYPE;
 318                 msgType.subType = MSG_NORMAL_SMS;
 319         }
 320         else if (msg_type == MSG_TYPE_SMS_WAPPUSH)
 321         {
 322                 msgType.mainType = MSG_SMS_TYPE;
 323                 msgType.subType = MSG_WAP_SI_SMS;
 324         }
 325         else if (msg_type == MSG_TYPE_MMS)
 326         {
 327                 msgType.mainType = MSG_MMS_TYPE;
 328                 msgType.subType = MSG_SENDREQ_MMS;
 329         }
 330
 331         try
 332         {
 333                 err = pHandle->countMsgByType(&msgType, msg_count);
 334         }
 335         catch (MsgException& e)
 336         {
 337                 MSG_FATAL("%s", e.what());
 338                 return MSG_ERR_STORAGE_ERROR;
 339         }
 340
 341         return err;
 342 }
 343
 344
 345 EXPORT_API int msg_count_msg_by_contact(msg_handle_t handle, const msg_struct_t addr_info, msg_struct_t msg_thread_count_list)
 346 {
 347         msg_error_t err =  MSG_SUCCESS;
 348
 349         if (handle == NULL || addr_info == NULL)
 350         {
 351                 return -EINVAL;
 352         }
 353
 354         MsgHandle* pHandle = (MsgHandle*)handle;
 355         msg_struct_s *pAddr = (msg_struct_s *)addr_info;
 356         msg_struct_s *pCount = (msg_struct_s *)msg_thread_count_list;
 357
 358         try
 359         {
 360                 err = pHandle->countMsgByContact((MSG_THREAD_LIST_INDEX_INFO_S *)pAddr->data, (MSG_THREAD_COUNT_INFO_S *)pCount->data);
 361         }
 362         catch (MsgException& e)
 363         {
 364                 MSG_FATAL("%s", e.what());
 365                 return MSG_ERR_STORAGE_ERROR;
 366         }
 367
 368         return err;
 369 }
 370
 371
 372 EXPORT_API int msg_get_message(msg_handle_t handle, msg_message_id_t msg_id, msg_struct_t opq_msg, msg_struct_t send_opt)
 373 {
 374         msg_error_t err =  MSG_SUCCESS;
 375
 376         if (handle == NULL || !opq_msg)
 377         {
 378                 MSG_FATAL("handle or opq_msg is NULL");
 379                 return -EINVAL;
 380         }
 381
 382         MsgHandle* pHandle = (MsgHandle*)handle;
 383
 384         msg_struct_s *pMsgStruct = (msg_struct_s *)opq_msg;
 385         msg_struct_s *pStruct = (msg_struct_s *)send_opt;
 386
 387         try
 388         {
 389                 err = pHandle->getMessage(msg_id, (MSG_MESSAGE_HIDDEN_S *)pMsgStruct->data, (MSG_SENDINGOPT_S *)pStruct->data);
 390         }
 391         catch (MsgException& e)
 392         {
 393                 MSG_FATAL("%s", e.what());
 394                 return MSG_ERR_STORAGE_ERROR;
 395         }
 396
 397         return err;
 398 }
 399
 400
 401 EXPORT_API int msg_get_folder_view_list(msg_handle_t handle, msg_folder_id_t folder_id, const msg_struct_t sort_rule, msg_struct_list_s *msg_folder_view_list)
 402 {
 403         msg_error_t err =  MSG_SUCCESS;
 404
 405         if (handle == NULL)
 406         {
 407                 return -EINVAL;
 408         }
 409
 410         MsgHandle* pHandle = (MsgHandle*)handle;
 411         msg_struct_s *pStruct = (msg_struct_s *)sort_rule;
 412
 413         try
 414         {
 415                 if (sort_rule == NULL)
 416                 {
 417                         MSG_SORT_RULE_S sortRule = {0};
 418
 419                         sortRule.sortType = MSG_SORT_BY_READ_STATUS;
 420                         sortRule.bAscending = true;
 421
 422                         err = pHandle->getFolderViewList(folder_id, &sortRule, msg_folder_view_list);
 423                 }
 424                 else
 425                 {
 426                 err = pHandle->getFolderViewList(folder_id, (MSG_SORT_RULE_S *)pStruct->data, msg_folder_view_list);
 427         }
 428         }
 429         catch (MsgException& e)
 430         {
 431                 MSG_FATAL("%s", e.what());
 432                 return MSG_ERR_STORAGE_ERROR;
 433         }
 434
 435         return err;
 436 }
 437
 438
 439 EXPORT_API int msg_get_thread_view_list(msg_handle_t handle, const msg_struct_t sort_rule, msg_struct_list_s *msg_thread_view_list)
 440 {
 441         msg_error_t err =  MSG_SUCCESS;
 442
 443         if (handle == NULL)
 444         {
 445                 return -EINVAL;
 446         }
 447
 448         MsgHandle* pHandle = (MsgHandle*)handle;
 449         msg_struct_s *pStruct =(msg_struct_s *)sort_rule;
 450
 451         try
 452         {
 453                 if (sort_rule == NULL)
 454                 {
 455                         MSG_SORT_RULE_S sortRule = {0};
 456
 457                         sortRule.sortType = MSG_SORT_BY_THREAD_DATE;
 458                         sortRule.bAscending = false;
 459
 460                         err = pHandle->getThreadViewList(&sortRule, msg_thread_view_list);
 461                 }
 462                 else
 463                 {
 464                         err = pHandle->getThreadViewList((MSG_SORT_RULE_S *)pStruct->data, msg_thread_view_list);
 465                 }
 466         }
 467         catch (MsgException& e)
 468         {
 469                 MSG_FATAL("%s", e.what());
 470                 return MSG_ERR_STORAGE_ERROR;
 471         }
 472
 473         return err;
 474 }
 475
 476
 477 EXPORT_API int msg_get_conversation_view_list(msg_handle_t handle, msg_thread_id_t thread_id, msg_struct_list_s *msg_conv_view_list)
 478 {
 479         msg_error_t err =  MSG_SUCCESS;
 480
 481         if (handle == NULL)
 482         {
 483                 return -EINVAL;
 484         }
 485
 486         MsgHandle* pHandle = (MsgHandle*)handle;
 487
 488         try
 489         {
 490                 err = pHandle->getConversationViewList(thread_id, msg_conv_view_list);
 491         }
 492         catch (MsgException& e)
 493         {
 494                 MSG_FATAL("%s", e.what());
 495                 return MSG_ERR_STORAGE_ERROR;
 496         }
 497
 498         return err;
 499 }
 500
 501
 502 EXPORT_API int msg_delete_thread_message_list(msg_handle_t handle, msg_thread_id_t thread_id)
 503 {
 504         msg_error_t err =  MSG_SUCCESS;
 505
 506         if (handle == NULL)
 507         {
 508                 return -EINVAL;
 509         }
 510
 511         MsgHandle* pHandle = (MsgHandle*)handle;
 512
 513         try
 514         {
 515                 err = pHandle->deleteThreadMessageList(thread_id);
 516         }
 517         catch (MsgException& e)
 518         {
 519                 MSG_FATAL("%s", e.what());
 520                 return MSG_ERR_STORAGE_ERROR;
 521         }
 522
 523         return err;
 524 }
 525
 526
 527 EXPORT_API int msg_add_folder(msg_handle_t handle, const msg_struct_t folder_info)
 528 {
 529         msg_error_t err =  MSG_SUCCESS;
 530
 531         if (handle == NULL || folder_info == NULL)
 532         {
 533                 return -EINVAL;
 534         }
 535
 536         MsgHandle* pHandle = (MsgHandle*)handle;
 537         msg_struct_s *pStruct = (msg_struct_s *)folder_info;
 538
 539         try
 540         {
 541                 err = pHandle->addFolder((MSG_FOLDER_INFO_S *)pStruct->data);
 542         }
 543         catch (MsgException& e)
 544         {
 545                 MSG_FATAL("%s", e.what());
 546                 return MSG_ERR_STORAGE_ERROR;
 547         }
 548
 549         return err;
 550 }
 551
 552
 553 EXPORT_API int msg_update_folder(msg_handle_t handle, const msg_struct_t folder_info)
 554 {
 555         msg_error_t err =  MSG_SUCCESS;
 556
 557         if (handle == NULL || folder_info == NULL)
 558         {
 559                 return -EINVAL;
 560         }
 561
 562         MsgHandle* pHandle = (MsgHandle*)handle;
 563         msg_struct_s *pStruct = (msg_struct_s *)folder_info;
 564
 565         try
 566         {
 567                 err = pHandle->updateFolder((MSG_FOLDER_INFO_S *)pStruct->data);
 568         }
 569         catch (MsgException& e)
 570         {
 571                 MSG_FATAL("%s", e.what());
 572                 return MSG_ERR_STORAGE_ERROR;
 573         }
 574
 575         return err;
 576 }
 577
 578
 579 EXPORT_API int msg_delete_folder(msg_handle_t handle, msg_folder_id_t folder_id)
 580 {
 581         msg_error_t err =  MSG_SUCCESS;
 582
 583         if (handle == NULL)
 584         {
 585                 return -EINVAL;
 586         }
 587
 588         MsgHandle* pHandle = (MsgHandle*)handle;
 589
 590         try
 591         {
 592                 err = pHandle->deleteFolder(folder_id);
 593         }
 594         catch (MsgException& e)
 595         {
 596                 MSG_FATAL("%s", e.what());
 597                 return MSG_ERR_STORAGE_ERROR;
 598         }
 599
 600         return err;
 601 }
 602
 603
 604 EXPORT_API int msg_get_folder_list(msg_handle_t handle, msg_struct_list_s *folder_list)
 605 {
 606         msg_error_t err =  MSG_SUCCESS;
 607
 608         if (handle == NULL)
 609         {
 610                 return -EINVAL;
 611         }
 612
 613         MsgHandle* pHandle = (MsgHandle*)handle;
 614
 615         try
 616         {
 617                 err = pHandle->getFolderList(folder_list);
 618         }
 619         catch (MsgException& e)
 620         {
 621                 MSG_FATAL("%s", e.what());
 622                 return MSG_ERR_STORAGE_ERROR;
 623         }
 624
 625         return err;
 626 }
 627
 628
 629 EXPORT_API int msg_generate_message(msg_handle_t handle, msg_message_type_t msg_type, msg_folder_id_t folder_id, unsigned int num_msg)
 630 {
 631         if (handle == NULL)
 632         {
 633                 MSG_DEBUG("Handle is NULL");
 634                 return -EINVAL;
 635         }
 636
 637         if (folder_id >= MSG_MAX_FOLDER_ID)
 638         {
 639                 MSG_DEBUG("folderId is invalid [%d]", folder_id);
 640                 return -EINVAL;
 641         }
 642
 643         MSG_DEBUG("type : %d, folder : %d, num_msg : %d", msg_type, folder_id, num_msg);
 644
 645         int err = 0;
 646         MSG_SENDINGOPT_S sendingOpt = {0};
 647         sendingOpt.bSetting = false;
 648
 649         char strMsg[20] = {0};
 650         char prefix[10] ="0103001";
 651 //      int postfix = 8111;
 652         int postfix = 0;
 653
 654         srand(getpid());
 655
 656         msg_struct_s *msg_s = NULL;
 657         msg_struct_s *addr_s = NULL;
 658         MSG_MESSAGE_HIDDEN_S *msgInfo = NULL;
 659         MSG_ADDRESS_INFO_S *addrInfo = NULL;
 660
 661         for (unsigned int i = 0; i < num_msg; i++)
 662         {
 663                 msg_s = (msg_struct_s *)msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
 664                 msgInfo = (MSG_MESSAGE_HIDDEN_S *)msg_s->data;
 665
 666                 msgInfo->folderId = folder_id;
 667
 668                 if (msg_type == MSG_TYPE_MMS)
 669                 {
 670                         msgInfo->mainType = MSG_MMS_TYPE;
 671                         msgInfo->subType = MSG_SENDREQ_MMS;
 672                 }
 673                 else
 674                 {
 675                         msgInfo->mainType = MSG_SMS_TYPE;
 676                         msgInfo->subType = MSG_NORMAL_SMS;
 677
 678                         snprintf(strMsg, sizeof(strMsg), "test msg %d", i);
 679                         msgInfo->dataSize = strlen(strMsg);
 680                         msgInfo->pData = (void*)new char[msgInfo->dataSize+1];
 681             memcpy((char *)msgInfo->pData, strMsg, msgInfo->dataSize);
 682             ((char*) msgInfo->pData)[msgInfo->dataSize] = '\0';
 683                 }
 684
 685                 msgInfo->storageId = MSG_STORAGE_PHONE;
 686
 687                 msgInfo->addr_list->nCount = 1;
 688
 689                 addr_s = (msg_struct_s *)msgInfo->addr_list->msg_struct_info[0];
 690
 691                 addrInfo = (MSG_ADDRESS_INFO_S *)addr_s->data;
 692
 693                 addrInfo->addressType = MSG_ADDRESS_TYPE_PLMN;
 694                 postfix = rand()%10000;
 695                 snprintf(addrInfo->addressVal, MAX_ADDRESS_VAL_LEN+1, "%s%04d", prefix, postfix);
 696
 697                 addrInfo->recipientType = MSG_RECIPIENTS_TYPE_TO;
 698
 699                 time(&(msgInfo->displayTime));
 700
 701                 msgInfo->networkStatus = MSG_NETWORK_NOT_SEND;
 702                 msgInfo->bRead = false;
 703                 msgInfo->bProtected = false;
 704                 msgInfo->priority = MSG_MESSAGE_PRIORITY_NORMAL;
 705
 706                 if (folder_id == MSG_OUTBOX_ID || folder_id == MSG_SENTBOX_ID)
 707                         msgInfo->direction = MSG_DIRECTION_TYPE_MO;
 708                 else
 709                         msgInfo->direction = MSG_DIRECTION_TYPE_MT;
 710
 711                 if (msg_type == MSG_TYPE_MMS)
 712                 {
 713                         snprintf(msgInfo->subject, MAX_SUBJECT_LEN+1, "subject %d", i);
 714
 715                         if(folder_id == MSG_INBOX_ID) msgInfo->networkStatus = MSG_NETWORK_RETRIEVE_SUCCESS;
 716
 717                         //MMS_MESSAGE_DATA_S* mms_data;
 718                         //MMS_PAGE_S* page[2];
 719                         //MMS_MEDIA_S* media[5];
 720
 721 //                      mms_data = msg_mms_create_message();
 722
 723 //                      msg_mms_set_rootlayout(mms_data, 100, 100, 0xffffff);
 724 //                      msg_mms_add_region(mms_data, "Image", 0, 50, 100, 50, 0xffffff);
 725 //                      msg_mms_add_region(mms_data, "Text", 0, 0, 100, 50, 0xffffff);
 726
 727                         //------------>  1st Slide Composing
 728 //                      page[0] = msg_mms_add_page(mms_data, 5440);
 729
 730 //                      media[0] = msg_mms_add_media(page[0], MMS_SMIL_MEDIA_IMG, "Image", (char*)"/opt/etc/msg-service/P091120_104633.jpg");
 731 //                      media[1] = msg_mms_add_media(page[0], MMS_SMIL_MEDIA_AUDIO, NULL, (char*)"/opt/etc/msg-service/audio.amr");
 732 //                      media[2] = msg_mms_add_media(page[0], MMS_SMIL_MEDIA_TEXT, "Text", (char*)"/opt/etc/msg-service/Temp0_2.txt");
 733 //                      media[2]->sMedia.sText.nColor = 0x000000;
 734 //                      media[2]->sMedia.sText.nSize = MMS_SMIL_FONT_SIZE_NORMAL;
 735 //                      media[2]->sMedia.sText.bBold = true;
 736
 737                         //------------>  2nd Slide Composing
 738 //                      page[1] = msg_mms_add_page(mms_data, 4544);
 739
 740 //                      media[3] = msg_mms_add_media(page[1], MMS_SMIL_MEDIA_TEXT, "Text", (char*)"/opt/etc/msg-service/Temp1_0.txt");
 741 //                      media[3]->sMedia.sText.nColor = 0x000000;
 742 //                      media[3]->sMedia.sText.nSize = MMS_SMIL_FONT_SIZE_NORMAL;
 743 //                      media[3]->sMedia.sText.bItalic = true;
 744 //                      media[4] = msg_mms_add_media(page[1], MMS_SMIL_MEDIA_VIDEO, "Text", (char*)"/opt/etc/msg-service/V091120_104905.3gp");
 745 //                      strncpy(media[4]->szAlt, "Video Load Fail", MAX_SMIL_ALT_LEN-1);
 746
 747                         //FIXME msg_mms_set_message_body((msg_message_t)&msgInfo, mms_data);
 748
 749 //                      msg_mms_destroy_message(mms_data);
 750                 }
 751
 752                 //err = msg_add_message(handle, (msg_message_t)&msgInfo, &sendingOpt);
 753                 try
 754                 {
 755                         MsgHandle* pHandle = (MsgHandle*)handle;
 756                         err = pHandle->addMessage(msgInfo, &sendingOpt);
 757                 }
 758                 catch (MsgException& e)
 759                 {
 760                         MSG_FATAL("%s", e.what());
 761                         return MSG_ERR_STORAGE_ERROR;
 762                 }
 763
 764                 if (msg_type == MSG_TYPE_MMS && msgInfo->pMmsData) //free pMmsData directly. It is added to enhance performance
 765                         delete [] static_cast<char*>(msgInfo->pMmsData);
 766
 767                 if (err < 0)
 768                 {
 769                         MSG_DEBUG("err [%d]", err);
 770                         return err;
 771                 }
 772
 773                 msg_release_struct((msg_struct_t *)&msg_s);
 774         }
 775
 776         return MSG_SUCCESS;
 777 }
 778
 779
 780 EXPORT_API int msg_generate_sms(msg_handle_t handle, msg_folder_id_t folder_id, unsigned int num_msg)
 781 {
 782         MSG_DEBUG("folder %d, num_msg %d", folder_id, num_msg);
 783
 784         if (handle == NULL)
 785         {
 786                 MSG_DEBUG("Handle is NULL");
 787                 return -EINVAL;
 788         }
 789
 790         if (folder_id >= MSG_MAX_FOLDER_ID)
 791         {
 792                 MSG_DEBUG("folderId is invalid");
 793                 return -EINVAL;
 794         }
 795
 796         int err = 0;
 797         char strMsg[20] = {0};
 798         char prefix[10] ="0103001";
 799         int postfix = 0;
 800
 801         MSG_SENDINGOPT_S sendingOpt = {0};
 802         sendingOpt.bSetting = false;
 803
 804         srand(getpid());
 805
 806         msg_struct_s *msg_s = NULL;
 807         msg_struct_s *addr_s = NULL;
 808         MSG_MESSAGE_HIDDEN_S *msgInfo = NULL;
 809         MSG_ADDRESS_INFO_S *addrInfo = NULL;
 810
 811         for (unsigned int i = 0; i < num_msg; i++)
 812         {
 813                 msg_s = (msg_struct_s *)msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
 814                 msgInfo = (MSG_MESSAGE_HIDDEN_S *)msg_s->data;
 815
 816                 msgInfo->msgId  = 0; // It should be set 0
 817                 msgInfo->folderId = folder_id;
 818
 819                 msgInfo->mainType = MSG_SMS_TYPE;
 820                 msgInfo->subType = 0;
 821
 822                 msgInfo->storageId = MSG_STORAGE_PHONE;
 823
 824                 snprintf(strMsg, sizeof(strMsg), "test %d", i);
 825                 msgInfo->dataSize = strlen(strMsg);
 826                 msgInfo->pData = strMsg;
 827
 828                 msgInfo->addr_list->nCount = 1;
 829
 830                 addr_s = (msg_struct_s *)msgInfo->addr_list->msg_struct_info[0];
 831
 832                 addrInfo = (MSG_ADDRESS_INFO_S *)addr_s->data;
 833
 834                 addrInfo->addressType = MSG_ADDRESS_TYPE_PLMN;
 835                 postfix = rand()%10000;
 836                 snprintf(addrInfo->addressVal, MAX_ADDRESS_VAL_LEN+1, "%s%04d", prefix, postfix);
 837
 838                 addrInfo->recipientType = MSG_RECIPIENTS_TYPE_TO;
 839
 840                 time(&(msgInfo->displayTime));
 841
 842                 msgInfo->networkStatus = MSG_NETWORK_NOT_SEND;
 843                 msgInfo->bRead = false;
 844                 msgInfo->bProtected = false;
 845                 msgInfo->priority = MSG_MESSAGE_PRIORITY_NORMAL;
 846                 msgInfo->direction = MSG_DIRECTION_TYPE_MO;
 847
 848 //              err = msg_add_message(handle, (msg_message_t) &msgInfo, &sendingOpt);
 849                 try
 850                 {
 851                         MsgHandle* pHandle = (MsgHandle*)handle;
 852                         err = pHandle->addMessage(msgInfo, &sendingOpt);
 853                 }
 854                 catch (MsgException& e)
 855                 {
 856                         MSG_FATAL("%s", e.what());
 857                         return MSG_ERR_STORAGE_ERROR;
 858                 }
 859
 860                 if (err < 0)
 861                 {
 862                         MSG_DEBUG("err [%d]", err);
 863                         return err;
 864                 }
 865
 866                 msg_release_struct((msg_struct_t *)&msg_s);
 867         }
 868
 869         return MSG_SUCCESS;
 870 }
 871
 872
 873 EXPORT_API int msg_get_quick_panel_data(msg_handle_t handle, msg_quickpanel_type_t type, msg_struct_t opq_msg)
 874 {
 875         msg_error_t err =  MSG_SUCCESS;
 876
 877         if (handle == NULL || !opq_msg )
 878         {
 879                 MSG_FATAL("handle or opq_msg is NULL");
 880                 return -EINVAL;
 881         }
 882
 883         MsgHandle* pHandle = (MsgHandle*)handle;
 884         msg_struct_s *pMsg = (msg_struct_s *)opq_msg;
 885
 886         try
 887         {
 888                 err = pHandle->getQuickPanelData(type, (MSG_MESSAGE_HIDDEN_S *)pMsg->data);
 889         }
 890         catch (MsgException& e)
 891         {
 892                 MSG_FATAL("%s", e.what());
 893                 return MSG_ERR_STORAGE_ERROR;
 894         }
 895
 896         return err;
 897 }
 898
 899
 900 EXPORT_API int msg_reset_database(msg_handle_t handle)
 901 {
 902         msg_error_t err =  MSG_SUCCESS;
 903
 904         if (handle == NULL)
 905         {
 906                 return -EINVAL;
 907         }
 908
 909         MsgHandle* pHandle = (MsgHandle*)handle;
 910
 911         try
 912         {
 913                 err = pHandle->resetDatabase();
 914         }
 915         catch (MsgException& e)
 916         {
 917                 MSG_FATAL("%s", e.what());
 918                 return MSG_ERR_STORAGE_ERROR;
 919         }
 920
 921         return err;
 922 }
 923
 924
 925 EXPORT_API int msg_get_mem_size(msg_handle_t handle, unsigned int* memsize)
 926 {
 927         msg_error_t err =  MSG_SUCCESS;
 928
 929         if (handle == NULL)
 930         {
 931                 return -EINVAL;
 932         }
 933
 934         MsgHandle* pHandle = (MsgHandle*)handle;
 935
 936         try
 937         {
 938                 err = pHandle->getMemSize(memsize);
 939         }
 940         catch (MsgException& e)
 941         {
 942                 MSG_FATAL("%s", e.what());
 943                 return MSG_ERR_STORAGE_ERROR;
 944         }
 945
 946         return err;
 947
 948 }
 949
 950 EXPORT_API int msg_backup_message(msg_handle_t handle)
 951 {
 952         msg_error_t err =  MSG_SUCCESS;
 953
 954         if (handle == NULL)
 955         {
 956                 return -EINVAL;
 957         }
 958
 959         MsgHandle* pHandle = (MsgHandle*)handle;
 960
 961         try
 962         {
 963                 err = pHandle->backupMessage();
 964         }
 965         catch (MsgException& e)
 966         {
 967                 MSG_FATAL("%s", e.what());
 968                 return MSG_ERR_STORAGE_ERROR;
 969         }
 970
 971         return err;
 972 }
 973
 974
 975 EXPORT_API int msg_restore_message(msg_handle_t handle)
 976 {
 977         msg_error_t err =  MSG_SUCCESS;
 978
 979         if (handle == NULL)
 980         {
 981                 return -EINVAL;
 982         }
 983
 984         MsgHandle* pHandle = (MsgHandle*)handle;
 985
 986         try
 987         {
 988                 err = pHandle->restoreMessage();
 989         }
 990         catch (MsgException& e)
 991         {
 992                 MSG_FATAL("%s", e.what());
 993                 return MSG_ERR_STORAGE_ERROR;
 994         }
 995
 996         return err;
 997 }
 998
 999
1000 EXPORT_API int msg_search_message_for_thread_view(msg_handle_t handle, const char *search_string, msg_struct_list_s *msg_thread_view_list)
1001 {
1002         msg_error_t err =  MSG_SUCCESS;
1003
1004         if (handle == NULL || search_string == NULL)
1005         {
1006                 return -EINVAL;
1007         }
1008
1009         if (strlen(search_string) <= 0 || strlen(search_string) > MAX_MSG_TEXT_LEN)
1010         {
1011                 return -EINVAL;
1012         }
1013
1014         MsgHandle* pHandle = (MsgHandle*)handle;
1015
1016         try
1017         {
1018                 err = pHandle->searchMessage(search_string, msg_thread_view_list);
1019         }
1020         catch (MsgException& e)
1021         {
1022                 MSG_FATAL("%s", e.what());
1023                 return MSG_ERR_STORAGE_ERROR;
1024         }
1025
1026         return err;
1027 }
1028
1029
1030 EXPORT_API int msg_search_message(msg_handle_t handle, const msg_struct_t msg_search_conditions, int offset, int limit, msg_struct_list_s *msg_list)
1031 {
1032         msg_error_t err =  MSG_SUCCESS;
1033
1034         if (handle == NULL || msg_search_conditions == NULL)
1035         {
1036                 return -EINVAL;
1037         }
1038
1039         MsgHandle* pHandle = (MsgHandle*)handle;
1040         msg_struct_s *pStruct = (msg_struct_s *)msg_search_conditions;
1041
1042         try
1043         {
1044                 err = pHandle->searchMessage((MSG_SEARCH_CONDITION_S *)pStruct->data, offset, limit, msg_list);
1045         }
1046         catch (MsgException& e)
1047         {
1048                 MSG_FATAL("%s", e.what());
1049                 return MSG_ERR_STORAGE_ERROR;
1050         }
1051
1052         return err;
1053 }
1054
1055 EXPORT_API int msg_get_reject_msg_list(msg_handle_t handle, const char *phone_num, msg_struct_list_s *msg_reject_msg_list)
1056 {
1057         msg_error_t err =  MSG_SUCCESS;
1058
1059         if (handle == NULL)
1060         {
1061                 return -EINVAL;
1062         }
1063
1064         MsgHandle* pHandle = (MsgHandle*)handle;
1065
1066         try
1067         {
1068                 err = pHandle->getRejectMsgList(phone_num, msg_reject_msg_list);
1069         }
1070         catch (MsgException& e)
1071         {
1072                 MSG_FATAL("%s", e.what());
1073                 return MSG_ERR_STORAGE_ERROR;
1074         }
1075
1076         return err;
1077 }
1078
1079
1080 EXPORT_API int msg_reg_storage_change_callback(msg_handle_t handle, msg_storage_change_cb cb, void *user_param)
1081 {
1082         msg_error_t err =  MSG_SUCCESS;
1083
1084         if (handle == NULL || cb == NULL)
1085         {
1086                 return -EINVAL;
1087         }
1088
1089         MsgHandle* pHandle = (MsgHandle*)handle;
1090
1091         try
1092         {
1093                 err = pHandle->regStorageChangeCallback(cb, user_param);
1094         }
1095         catch (MsgException& e)
1096         {
1097                 MSG_FATAL("%s", e.what());
1098                 return MSG_ERR_CALLBACK_ERROR;
1099         }
1100
1101         return err;
1102 }
1103
1104
1105 EXPORT_API int msg_get_report_status(msg_handle_t handle, msg_message_id_t msg_id, msg_struct_t report_status)
1106 {
1107         msg_error_t err =  MSG_SUCCESS;
1108
1109         if (handle == NULL || msg_id < 1)
1110         {
1111                 return -EINVAL;
1112         }
1113
1114         MsgHandle* pHandle = (MsgHandle*)handle;
1115         msg_struct_s *pStruct = (msg_struct_s *)report_status;
1116
1117         try
1118         {
1119                 err = pHandle->getReportStatus(msg_id, (MSG_REPORT_STATUS_INFO_S *)pStruct->data);
1120         }
1121         catch (MsgException& e)
1122         {
1123                 MSG_FATAL("%s", e.what());
1124                 return MSG_ERR_STORAGE_ERROR;
1125         }
1126
1127         return err;
1128 }
1129
1130 EXPORT_API int msg_get_address_list(msg_handle_t handle, msg_thread_id_t thread_id, msg_struct_list_s *msg_address_list)
1131 {
1132         msg_error_t err =  MSG_SUCCESS;
1133
1134         if (handle == NULL)
1135         {
1136                 return -EINVAL;
1137         }
1138
1139         MsgHandle* pHandle = (MsgHandle*)handle;
1140
1141         try
1142         {
1143                 err = pHandle->getAddressList(thread_id, msg_address_list);
1144         }
1145         catch (MsgException& e)
1146         {
1147                 MSG_FATAL("%s", e.what());
1148                 return MSG_ERR_STORAGE_ERROR;
1149         }
1150
1151         return err;
1152 }
1153
1154
1155 EXPORT_API int msg_get_thread_id_by_address(msg_handle_t handle, msg_struct_list_s *msg_address_list, msg_thread_id_t *thread_id)
1156 {
1157         msg_error_t err =  MSG_SUCCESS;
1158
1159         if (handle == NULL || msg_address_list->nCount < 1)
1160         {
1161                 return -EINVAL;
1162         }
1163
1164         MsgHandle* pHandle = (MsgHandle*)handle;
1165
1166         try
1167         {
1168                 err = pHandle->getThreadIdByAddress(msg_address_list, thread_id);
1169         }
1170         catch (MsgException& e)
1171         {
1172                 MSG_FATAL("%s", e.what());
1173                 return MSG_ERR_STORAGE_ERROR;
1174         }
1175
1176         return err;
1177 }
1178
1179
1180 EXPORT_API int msg_get_thread(msg_handle_t handle, msg_thread_id_t thread_id, msg_struct_t msg_thread)
1181 {
1182         msg_error_t err =  MSG_SUCCESS;
1183
1184         if (handle == NULL || msg_thread == NULL ) {
1185                 MSG_FATAL("handle or msg_thread is NULL");
1186                 return -EINVAL;
1187         }
1188
1189         MsgHandle* pHandle = (MsgHandle*)handle;
1190         msg_struct_s *msgThread = (msg_struct_s *)msg_thread;
1191         if (msgThread->type != MSG_STRUCT_THREAD_INFO) {
1192                 MSG_FATAL("Invaild type. type [%d]", msgThread->type);
1193                 return MSG_ERR_INVALID_PARAMETER;
1194         }
1195
1196         MSG_THREAD_VIEW_S* pThreadInfo = (MSG_THREAD_VIEW_S *)msgThread->data;
1197
1198         try
1199         {
1200                 err = pHandle->getThread(thread_id, pThreadInfo);
1201         }
1202         catch (MsgException& e)
1203         {
1204                 MSG_FATAL("%s", e.what());
1205                 return MSG_ERR_STORAGE_ERROR;
1206         }
1207
1208         return err;
1209 }
1210
1211
1212 EXPORT_API int msg_get_message_list(msg_handle_t handle, msg_folder_id_t folder_id, msg_thread_id_t thread_id, msg_message_type_t msg_type, msg_storage_id_t storage_id, msg_struct_list_s *msg_list)
1213 {
1214         msg_error_t err =  MSG_SUCCESS;
1215
1216         if (handle == NULL) {
1217                 return -EINVAL;
1218         }
1219
1220         MsgHandle* pHandle = (MsgHandle*)handle;
1221
1222         try
1223         {
1224                 err = pHandle->getMessageList(folder_id, thread_id, msg_type, storage_id, msg_list);
1225         }
1226         catch (MsgException& e)
1227         {
1228                 MSG_FATAL("%s", e.what());
1229                 return MSG_ERR_STORAGE_ERROR;
1230         }
1231
1232         return err;
1233 }
1234
1235 static int msg_thread_get_msg_type(int mainType, int subType)
1236 {
1237         if (mainType == MSG_SMS_TYPE)
1238         {
1239                 if (subType == MSG_CB_SMS)
1240                         return MSG_TYPE_SMS_CB;
1241                 else if (subType == MSG_JAVACB_SMS)
1242                         return MSG_TYPE_SMS_JAVACB;
1243                 else if (subType == MSG_WAP_SI_SMS || subType == MSG_WAP_SL_SMS)
1244                         return MSG_TYPE_SMS_WAPPUSH;
1245                 else if (subType == MSG_MWI_VOICE_SMS || subType == MSG_MWI_FAX_SMS
1246                                 || subType == MSG_MWI_EMAIL_SMS || subType == MSG_MWI_OTHER_SMS)
1247                         return MSG_TYPE_SMS_MWI;
1248                 else    if (subType == MSG_SYNCML_CP)
1249                         return MSG_TYPE_SMS_SYNCML;
1250                 else    if (subType == MSG_REJECT_SMS)
1251                         return MSG_TYPE_SMS_REJECT;
1252                 else
1253                         return MSG_TYPE_SMS;
1254         }
1255         else if (mainType == MSG_MMS_TYPE)
1256         {
1257                 if (subType == MSG_NOTIFICATIONIND_MMS)
1258                         return MSG_TYPE_MMS_NOTI;
1259                 else if (subType == MSG_SENDREQ_JAVA_MMS)
1260                         return MSG_TYPE_MMS_JAVA;
1261                 else
1262                         return MSG_TYPE_MMS;
1263         }
1264         else
1265                 return MSG_TYPE_INVALID;
1266 }
1267
1268
1269 int msg_syncml_info_get_int(void *syncml_info, int field)
1270 {
1271         int result = -1;
1272         MSG_SYNCML_MESSAGE_S *pSync = (MSG_SYNCML_MESSAGE_S *)syncml_info;
1273         switch(field)
1274         {
1275         case MSG_SYNCML_INFO_EXTID_INT:
1276                 result = pSync->extId;
1277                 break;
1278         case MSG_SYNCML_INFO_PINCODE_INT:
1279                 result = pSync->pinCode;
1280                 break;
1281         default:
1282                 result = -1;
1283                 break;
1284         }
1285         return result;
1286 }
1287
1288 int msg_count_info_get_int(void *count_info, int field)
1289 {
1290         int result = -1;
1291         MSG_COUNT_INFO_S *pCount = (MSG_COUNT_INFO_S *)count_info;
1292         switch(field)
1293         {
1294         case MSG_COUNT_INFO_READ_INT:
1295                 result = pCount->nReadCnt;
1296                 break;
1297         case MSG_COUNT_INFO_UNREAD_INT:
1298                 result = pCount->nUnreadCnt;
1299                 break;
1300         case MSG_COUNT_INFO_SMS_INT:
1301                 result = pCount->nSms;
1302                 break;
1303         case MSG_COUNT_INFO_MMS_INT:
1304                 result = pCount->nMms;
1305                 break;
1306         default:
1307                 result = -1;
1308                 break;
1309         }
1310         return result;
1311 }
1312
1313 int msg_thread_count_get_int(void *count_info, int field)
1314 {
1315         int result = -1;
1316         MSG_THREAD_COUNT_INFO_S *pCount = (MSG_THREAD_COUNT_INFO_S *)count_info;
1317         switch(field)
1318         {
1319         case MSG_THREAD_COUNT_TOTAL_INT:
1320                 result = pCount->totalCount;
1321                 break;
1322         case MSG_THREAD_COUNT_UNREAD_INT:
1323                 result = pCount->unReadCount;
1324                 break;
1325         case MSG_THREAD_COUNT_SMS_INT:
1326                 result = pCount->smsMsgCount;
1327                 break;
1328         case MSG_THREAD_COUNT_MMS_INT:
1329                 result = pCount->mmsMsgCount;
1330                 break;
1331         default:
1332                 result = -1;
1333                 break;
1334         }
1335         return result;
1336 }
1337
1338 int msg_thread_index_get_int(void *index_info, int field)
1339 {
1340         int result = -1;
1341         MSG_THREAD_LIST_INDEX_S *pIndex = (MSG_THREAD_LIST_INDEX_S *)index_info;
1342         switch(field)
1343         {
1344         case MSG_THREAD_LIST_INDEX_CONTACTID_INT:
1345                 result = pIndex->contactId;
1346                 break;
1347         default:
1348                 result = -1;
1349                 break;
1350         }
1351         return result;
1352 }
1353
1354 int msg_sortrule_get_int(void *sort_info, int field)
1355 {
1356         int result = -1;
1357         MSG_SORT_RULE_S *pSort = (MSG_SORT_RULE_S *)sort_info;
1358         switch(field)
1359         {
1360         case MSG_SORT_RULE_SORT_TYPE_INT:
1361                 result = pSort->sortType;
1362                 break;
1363         default:
1364                 result = -1;
1365                 break;
1366         }
1367         return result;
1368 }
1369
1370 int msg_folder_info_get_int(void *folder_info, int field)
1371 {
1372         int result = -1;
1373         MSG_FOLDER_INFO_S *pFolder = (MSG_FOLDER_INFO_S *)folder_info;
1374         switch(field)
1375         {
1376         case MSG_FOLDER_INFO_ID_INT:
1377                 result = pFolder->folderId;
1378                 break;
1379         case MSG_FOLDER_INFO_TYPE_INT:
1380                 result = pFolder->folderType;
1381                 break;
1382         default:
1383                 result = -1;
1384                 break;
1385         }
1386         return result;
1387 }
1388
1389 int msg_thread_info_get_int(void *data, int field)
1390 {
1391         int result = -1;
1392         MSG_THREAD_VIEW_S *pThread = (MSG_THREAD_VIEW_S *)data;
1393
1394         switch(field)
1395         {
1396         case MSG_THREAD_ID_INT :
1397                 result = pThread->threadId;
1398                 break;
1399         case MSG_THREAD_MSG_TYPE_INT :
1400                 result = msg_thread_get_msg_type(pThread->mainType, pThread->subType);
1401                 break;
1402         case MSG_THREAD_MSG_TIME_INT :
1403                 result = pThread->threadTime;
1404                 break;
1405         case MSG_THREAD_DIRECTION_INT :
1406                 result = pThread->direction;
1407                 break;
1408         case MSG_THREAD_UNREAD_COUNT_INT :
1409                 result = pThread->unreadCnt;
1410                 break;
1411         case MSG_THREAD_SMS_COUNT_INT :
1412                 result = pThread->smsCnt;
1413                 break;
1414         case MSG_THREAD_MMS_COUNT_INT :
1415                 result = pThread->mmsCnt;
1416                 break;
1417         default:
1418                 result = -1;
1419                 break;
1420         }
1421         return result;
1422 }
1423
1424 int msg_search_condition_get_int(void *condition_info, int field)
1425 {
1426         int result = -1;
1427         MSG_SEARCH_CONDITION_S *pCond = (MSG_SEARCH_CONDITION_S *)condition_info;
1428         switch(field)
1429         {
1430         case MSG_SEARCH_CONDITION_FOLDERID_INT:
1431                 result = pCond->folderId;
1432                 break;
1433         case MSG_SEARCH_CONDITION_MSGTYPE_INT:
1434                 result = pCond->msgType;
1435                 break;
1436         case MSG_SEARCH_CONDITION_RESERVED_INT:
1437                 result = pCond->reserved;
1438                 break;
1439         default:
1440                 result = -1;
1441                 break;
1442         }
1443         return result;
1444 }
1445
1446 int msg_report_status_get_int(void *report_info, int field)
1447 {
1448         int result = -1;
1449         MSG_REPORT_STATUS_INFO_S *pReport = (MSG_REPORT_STATUS_INFO_S *)report_info;
1450         switch(field)
1451         {
1452         case MSG_REPORT_STATUS_DELIVERY_STATUS_INT:
1453                 result = pReport->deliveryStatus;
1454                 break;
1455         case MSG_REPORT_STATUS_DELIVERY_TIME_INT:
1456                 result = pReport->deliveryStatusTime;
1457                 break;
1458         case MSG_REPORT_STATUS_READ_STATUS_INT:
1459                 result = pReport->readStatus;
1460                 break;
1461         case MSG_REPORT_STATUS_READ_TIME_INT:
1462                 result = pReport->readStatusTime;
1463                 break;
1464         default:
1465                 result = -1;
1466                 break;
1467         }
1468         return result;
1469 }
1470
1471 char* msg_folder_info_get_str(void *folder_info, int field)
1472 {
1473         char *result = NULL;
1474         MSG_FOLDER_INFO_S *pFolder = (MSG_FOLDER_INFO_S *)folder_info;
1475         switch(field)
1476         {
1477         case MSG_FOLDER_INFO_NAME_STR:
1478                 result = pFolder->folderName;
1479                 break;
1480         default:
1481                 result = NULL;
1482                 break;
1483         }
1484         return result;
1485 }
1486
1487 char *msg_thread_info_get_str(void *data, int field)
1488 {
1489         char *ret_str = NULL;
1490         MSG_THREAD_VIEW_S *pThread = (MSG_THREAD_VIEW_S *)data;
1491
1492         switch(field)
1493         {
1494         case MSG_THREAD_NAME_STR :
1495                 ret_str = pThread->threadName;
1496                 break;
1497         case MSG_THREAD_MSG_DATA_STR :
1498                 ret_str = pThread->threadData;
1499                 break;
1500         default:
1501                 break;
1502         }
1503
1504         return ret_str;
1505 }
1506
1507 char* msg_search_condition_get_str(void *condition_info, int field, int size)
1508 {
1509         char *result = NULL;
1510         MSG_SEARCH_CONDITION_S *search_cond = (MSG_SEARCH_CONDITION_S *)condition_info;
1511         switch(field)
1512         {
1513         case MSG_SEARCH_CONDITION_ADDRESS_VALUE_STR:
1514                 result = search_cond->pAddressVal;
1515                 break;
1516         case MSG_SEARCH_CONDITION_SEARCH_VALUE_STR:
1517                 result = search_cond->pSearchVal;
1518                 break;
1519
1520         default:
1521                 result = NULL;
1522                 break;
1523         }
1524         return result;
1525 }
1526
1527 bool msg_sendopt_get_bool(void *send_opt, int field)
1528 {
1529         bool result = false;
1530         MSG_SENDINGOPT_S *sendopt = (MSG_SENDINGOPT_S *)send_opt;
1531         switch(field)
1532         {
1533         case MSG_SEND_OPT_SETTING_BOOL:
1534                 result = sendopt->bDeliverReq;
1535                 break;
1536         case MSG_SEND_OPT_KEEPCOPY_BOOL:
1537                 result = sendopt->bDeliverReq;
1538                 break;
1539         case MSG_SEND_OPT_DELIVER_REQ_BOOL:
1540                 result = sendopt->bDeliverReq;
1541                 break;
1542         default:
1543                 break;
1544         }
1545         return result;
1546 }
1547
1548 bool msg_sortrule_get_bool(void *sort_rule, int field)
1549 {
1550         bool result = false;
1551         MSG_SORT_RULE_S *pSort = (MSG_SORT_RULE_S *)sort_rule;
1552         switch(field)
1553         {
1554         case MSG_SORT_RULE_ACSCEND_BOOL:
1555                 result = pSort->bAscending;
1556                 break;
1557         default:
1558                 break;
1559         }
1560         return result;
1561 }
1562
1563 int msg_sendopt_get_struct_handle(msg_struct_s *msg_struct, int field, void **value)
1564 {
1565         msg_error_t err =  MSG_SUCCESS;
1566         if(!msg_struct || !value)
1567                 return MSG_ERR_NULL_POINTER;
1568
1569         MSG_SENDINGOPT_S *sendopt = (MSG_SENDINGOPT_S *)msg_struct->data;
1570
1571         switch(field)
1572         {
1573         case MSG_SEND_OPT_MMS_OPT_HND:
1574                 *value = (void *)sendopt->mmsSendOpt;
1575                 break;
1576         case MSG_SEND_OPT_SMS_OPT_HND:
1577                 *value = (void *)sendopt->smsSendOpt;
1578                 break;
1579         default:
1580                 err = MSG_ERR_UNKNOWN;
1581                 break;
1582         }
1583         return err;
1584 }
1585
1586 int msg_syncml_get_struct_handle(msg_struct_s *msg_struct, int field, void **value)
1587 {
1588         msg_error_t err =  MSG_SUCCESS;
1589
1590         if(!msg_struct || !value)
1591                 return MSG_ERR_NULL_POINTER;
1592
1593         MSG_SYNCML_MESSAGE_S *pSync = (MSG_SYNCML_MESSAGE_S *)msg_struct->data;
1594         switch(field)
1595         {
1596         case MSG_SYNCML_INFO_MESSAGE_HND:
1597                 *value = (void *)pSync->msg;
1598                 break;
1599         default:
1600                 err = MSG_ERR_UNKNOWN;
1601                 break;
1602
1603         }
1604         return err;
1605 }
1606
1607 int msg_thread_index_get_struct_handle(msg_struct_s *msg_struct, int field, void **value)
1608 {
1609         msg_error_t err =  MSG_SUCCESS;
1610
1611         if(!msg_struct || !value)
1612                 return MSG_ERR_NULL_POINTER;
1613
1614         MSG_THREAD_LIST_INDEX_INFO_S *pIndex = (MSG_THREAD_LIST_INDEX_INFO_S *)msg_struct->data;
1615         switch(field)
1616         {
1617         case MSG_SYNCML_INFO_MESSAGE_HND:
1618                 *value = (void *)pIndex->msgAddrInfo;
1619                 break;
1620         default:
1621                 err = MSG_ERR_UNKNOWN;
1622                 break;
1623
1624         }
1625         return err;
1626 }
1627
1628 int msg_address_info_get_int(void *addr_info, int field)
1629 {
1630         int result = -1;
1631         MSG_ADDRESS_INFO_S *pAddr = (MSG_ADDRESS_INFO_S *)addr_info;
1632         switch(field)
1633         {
1634         case MSG_ADDRESS_INFO_ADDRESS_TYPE_INT:
1635                 result = pAddr->addressType;
1636                 break;
1637         case MSG_ADDRESS_INFO_RECIPIENT_TYPE_INT:
1638                 result = pAddr->recipientType;
1639                 break;
1640         case MSG_ADDRESS_INFO_CONTACT_ID_INT:
1641                 result = pAddr->contactId;
1642                 break;
1643         default:
1644                 break;
1645         }
1646         return result;
1647 }
1648 int msg_mms_sendopt_get_int(void *opt_info, int field)
1649 {
1650         int result = -1;
1651         MMS_SENDINGOPT_S *pOpt = (MMS_SENDINGOPT_S *)opt_info;
1652         switch(field)
1653         {
1654         case MSG_MMS_SENDOPTION_EXPIRY_TIME_INT:
1655                 result = pOpt->expiryTime;
1656                 break;
1657         case MSG_MMS_SENDOPTION_DELIVERY_TIME_INT:
1658                 result = pOpt->deliveryTime;
1659                 break;
1660         case MSG_MMS_SENDOPTION_PRIORITY_INT:
1661                 result = pOpt->priority;
1662                 break;
1663         default:
1664                 break;
1665         }
1666         return result;
1667 }
1668
1669 int msg_reject_message_get_int(void *msg_info, int field)
1670 {
1671         int result = -1;
1672         MSG_REJECT_MSG_INFO_S *pMsg = (MSG_REJECT_MSG_INFO_S *)msg_info;
1673         switch(field)
1674         {
1675         case MSG_REJECT_MESSAGE_MSGID_INT:
1676                 result = pMsg->msgId;
1677                 break;
1678         case MSG_REJECT_MESSAGE_DISPLAY_TIME_INT:
1679                 result = pMsg->displayTime;
1680                 break;
1681         default:
1682                 break;
1683         }
1684         return result;
1685 }
1686
1687 char* msg_address_info_get_str(void *addr_info, int field, int size)
1688 {
1689         char *result = NULL;
1690         MSG_ADDRESS_INFO_S *pAddr = (MSG_ADDRESS_INFO_S *)addr_info;
1691         switch(field)
1692         {
1693         case MSG_ADDRESS_INFO_ADDRESS_VALUE_STR:
1694                 result = pAddr->addressVal;
1695                 break;
1696         case MSG_ADDRESS_INFO_DISPLAYNAME_STR:
1697                 result = pAddr->displayName;
1698                 break;
1699
1700         default:
1701                 result = NULL;
1702                 break;
1703         }
1704         return result;
1705 }
1706
1707 char* msg_reject_message_get_str(void *msg_info, int field, int size)
1708 {
1709         char *result = NULL;
1710         MSG_REJECT_MSG_INFO_S *pMsg = (MSG_REJECT_MSG_INFO_S *)msg_info;
1711         switch(field)
1712         {
1713         case MSG_REJECT_MESSAGE_MSGTEXT_STR:
1714                 result = pMsg->msgText;
1715                 break;
1716         default:
1717                 result = NULL;
1718                 break;
1719         }
1720         return result;
1721 }
1722
1723 bool msg_mms_sendopt_get_bool(void *opt_info, int field)
1724 {
1725         bool result = false;
1726         MMS_SENDINGOPT_S *pOpt = (MMS_SENDINGOPT_S *)opt_info;
1727         switch(field)
1728         {
1729         case MSG_MMS_SENDOPTION_READ_REQUEST_BOOL:
1730                 result = pOpt->bReadReq;
1731                 break;
1732         case MSG_MMS_SENDOPTION_DELIVERY_CUSTOMTIME_BOOL:
1733                 result = pOpt->bUseDeliveryCustomTime;
1734                 break;
1735         default:
1736                 break;
1737         }
1738         return result;
1739 }
1740
1741 bool msg_sms_sendopt_get_bool(void *opt_info, int field)
1742 {
1743         bool result = false;
1744         SMS_SENDINGOPT_S *pOpt = (SMS_SENDINGOPT_S *)opt_info;
1745         switch(field)
1746         {
1747         case MSG_SMS_SENDOPT_REPLYPATH_BOOL:
1748                 result = pOpt->bReplyPath;
1749                 break;
1750         default:
1751                 break;
1752         }
1753         return result;
1754 }
1755
1756 int msg_syncml_info_set_int(void *syncml_info, int field, int value)
1757 {
1758
1759         msg_error_t err =  MSG_SUCCESS;
1760         if(!syncml_info)
1761                 return MSG_ERR_NULL_POINTER;
1762
1763     MSG_SYNCML_MESSAGE_S *pSync = (MSG_SYNCML_MESSAGE_S *)syncml_info;
1764     switch(field)
1765     {
1766     case MSG_SYNCML_INFO_EXTID_INT:
1767                 pSync->extId = value;
1768                 break;
1769     case MSG_SYNCML_INFO_PINCODE_INT:
1770                 pSync->pinCode = value;
1771                 break;
1772     default:
1773                 err = MSG_ERR_UNKNOWN;
1774                 break;
1775     }
1776
1777         return err;
1778 }
1779
1780 int msg_count_info_set_int(void *count_info, int field, int value)
1781 {
1782         msg_error_t err =  MSG_SUCCESS;
1783         if(!count_info)
1784                 return MSG_ERR_NULL_POINTER;
1785
1786     MSG_COUNT_INFO_S *pCount = (MSG_COUNT_INFO_S *)count_info;
1787
1788     switch(field)
1789     {
1790     case MSG_COUNT_INFO_READ_INT:
1791                 pCount->nReadCnt = value;
1792                 break;
1793     case MSG_COUNT_INFO_UNREAD_INT:
1794                 pCount->nUnreadCnt = value;
1795                 break;
1796     case MSG_COUNT_INFO_SMS_INT:
1797                 pCount->nSms = value;
1798                 break;
1799     case MSG_COUNT_INFO_MMS_INT:
1800                 pCount->nMms = value;
1801                 break;
1802     default:
1803                 err = MSG_ERR_UNKNOWN;
1804                 break;
1805     }
1806         return err;
1807 }
1808
1809 int msg_thread_count_set_int(void *count_info, int field, int value)
1810 {
1811         msg_error_t err =  MSG_SUCCESS;
1812         if(!count_info)
1813                 return MSG_ERR_NULL_POINTER;
1814
1815     MSG_THREAD_COUNT_INFO_S *pCount = (MSG_THREAD_COUNT_INFO_S *)count_info;
1816     switch(field)
1817     {
1818     case MSG_THREAD_COUNT_TOTAL_INT:
1819                 pCount->totalCount = value;
1820                 break;
1821     case MSG_THREAD_COUNT_UNREAD_INT:
1822                 pCount->unReadCount = value;
1823                 break;
1824     case MSG_THREAD_COUNT_SMS_INT:
1825                 pCount->smsMsgCount = value;
1826                 break;
1827     case MSG_THREAD_COUNT_MMS_INT:
1828                 pCount->mmsMsgCount = value;
1829                 break;
1830     default:
1831                 err = MSG_ERR_UNKNOWN;
1832                 break;
1833     }
1834         return err;
1835 }
1836
1837 int msg_thread_index_set_int(void *index_info, int field, int value)
1838 {
1839         msg_error_t err =  MSG_SUCCESS;
1840         if(!index_info)
1841                 return MSG_ERR_NULL_POINTER;
1842
1843     MSG_THREAD_LIST_INDEX_S *pIndex = (MSG_THREAD_LIST_INDEX_S *)index_info;
1844     switch(field)
1845     {
1846     case MSG_THREAD_LIST_INDEX_CONTACTID_INT:
1847                 pIndex->contactId = value;
1848                 break;
1849     default:
1850                 err = MSG_ERR_UNKNOWN;
1851                 break;
1852     }
1853
1854         return err;
1855 }
1856
1857 int msg_sortrule_set_int(void *sort_info, int field, int value)
1858 {
1859         msg_error_t err =  MSG_SUCCESS;
1860
1861         if(!sort_info)
1862                 return MSG_ERR_NULL_POINTER;
1863
1864     MSG_SORT_RULE_S *pSort = (MSG_SORT_RULE_S *)sort_info;
1865     switch(field)
1866     {
1867     case MSG_SORT_RULE_SORT_TYPE_INT:
1868                 pSort->sortType = value;
1869                 break;
1870     default:
1871                 err = MSG_ERR_UNKNOWN;
1872                 break;
1873     }
1874         return err;
1875 }
1876
1877 int msg_folder_info_set_int(void *folder_info, int field, int value)
1878 {
1879         msg_error_t err =  MSG_SUCCESS;
1880         if(!folder_info)
1881                 return MSG_ERR_NULL_POINTER;
1882
1883     MSG_FOLDER_INFO_S *pFolder = (MSG_FOLDER_INFO_S *)folder_info;
1884     switch(field)
1885     {
1886     case MSG_FOLDER_INFO_ID_INT:
1887                 pFolder->folderId = value;
1888                 break;
1889     case MSG_FOLDER_INFO_TYPE_INT:
1890                 pFolder->folderType = value;
1891                 break;
1892     default:
1893                 err = MSG_ERR_UNKNOWN;
1894                 break;
1895     }
1896
1897         return err;
1898 }
1899
1900 int msg_search_condition_set_int(void *condition_info, int field, int value)
1901 {
1902         msg_error_t err =  MSG_SUCCESS;
1903         if(!condition_info)
1904                 return MSG_ERR_NULL_POINTER;
1905
1906     MSG_SEARCH_CONDITION_S *pCond = (MSG_SEARCH_CONDITION_S *)condition_info;
1907     switch(field)
1908     {
1909     case MSG_SEARCH_CONDITION_FOLDERID_INT:
1910                 pCond->folderId = value;
1911                 break;
1912     case MSG_SEARCH_CONDITION_MSGTYPE_INT:
1913                 pCond->msgType = value;
1914                 break;
1915     case MSG_SEARCH_CONDITION_RESERVED_INT:
1916                 pCond->reserved = value;
1917                 break;
1918     default:
1919                 err = MSG_ERR_UNKNOWN;
1920                 break;
1921     }
1922
1923         return err;
1924 }
1925
1926 int msg_report_status_set_int(void *report_info, int field, int value)
1927 {
1928         msg_error_t err =  MSG_SUCCESS;
1929         if(!report_info)
1930                 return MSG_ERR_NULL_POINTER;
1931
1932     MSG_REPORT_STATUS_INFO_S *pReport = (MSG_REPORT_STATUS_INFO_S *)report_info;
1933     switch(field)
1934     {
1935     case MSG_REPORT_STATUS_DELIVERY_STATUS_INT:
1936                 pReport->deliveryStatus = value;
1937                 break;
1938     case MSG_REPORT_STATUS_DELIVERY_TIME_INT:
1939                 pReport->deliveryStatusTime = value;
1940                 break;
1941     case MSG_REPORT_STATUS_READ_STATUS_INT:
1942                 pReport->readStatus = value;
1943                 break;
1944     case MSG_REPORT_STATUS_READ_TIME_INT:
1945                 pReport->readStatusTime = value;
1946                 break;
1947     default:
1948                 err = MSG_ERR_UNKNOWN;
1949                 break;
1950     }
1951
1952         return err;
1953 }
1954
1955 int msg_folder_info_set_str(void *folder_info, int field, char *value, int size)
1956 {
1957         msg_error_t err =  MSG_SUCCESS;
1958         if(!folder_info || !value)
1959                 return MSG_ERR_NULL_POINTER;
1960     MSG_FOLDER_INFO_S *pFolder = (MSG_FOLDER_INFO_S *)folder_info;
1961     int _len = 0;
1962     (size > MAX_FOLDER_NAME_SIZE)? _len = MAX_FOLDER_NAME_SIZE : _len = size;
1963     switch(field)
1964     {
1965     case MSG_FOLDER_INFO_NAME_STR:
1966                 strncpy(pFolder->folderName, value, _len);
1967                 break;
1968     default:
1969                 err = MSG_ERR_UNKNOWN;
1970                 break;
1971     }
1972
1973         return err;
1974 }
1975
1976 int msg_search_condition_set_str(void *condition_info, int field, char *value, int size)
1977 {
1978         msg_error_t err =  MSG_SUCCESS;
1979         if(!condition_info || !value)
1980                 return MSG_ERR_NULL_POINTER;
1981
1982     MSG_SEARCH_CONDITION_S *search_cond = (MSG_SEARCH_CONDITION_S *)condition_info;
1983
1984     switch(field)
1985     {
1986     case MSG_SEARCH_CONDITION_ADDRESS_VALUE_STR:
1987                 search_cond->pAddressVal = value;
1988                 break;
1989     case MSG_SEARCH_CONDITION_SEARCH_VALUE_STR:
1990                 search_cond->pSearchVal = value;
1991                 break;
1992
1993     default:
1994                 err = MSG_ERR_UNKNOWN;
1995                 break;
1996     }
1997         return err;
1998 }
1999
2000 int msg_sendopt_set_bool(void *send_opt, int field, bool value)
2001 {
2002         msg_error_t err =  MSG_SUCCESS;
2003         if(!send_opt)
2004                 return MSG_ERR_NULL_POINTER;
2005
2006     MSG_SENDINGOPT_S *sendopt = (MSG_SENDINGOPT_S *)send_opt;
2007     switch(field)
2008     {
2009     case MSG_SEND_OPT_SETTING_BOOL:
2010                 sendopt->bDeliverReq = value;
2011                 break;
2012     case MSG_SEND_OPT_KEEPCOPY_BOOL:
2013                 sendopt->bDeliverReq = value;
2014                 break;
2015     case MSG_SEND_OPT_DELIVER_REQ_BOOL:
2016                 sendopt->bDeliverReq = value;
2017                 break;
2018     default:
2019                 err = MSG_ERR_UNKNOWN;
2020                 break;
2021     }
2022         return err;
2023 }
2024
2025 int msg_sortrule_set_bool(void *sort_rule, int field, bool value)
2026 {
2027         msg_error_t err =  MSG_SUCCESS;
2028         if(!sort_rule)
2029                 return MSG_ERR_NULL_POINTER;
2030
2031     MSG_SORT_RULE_S *pSort = (MSG_SORT_RULE_S *)sort_rule;
2032     switch(field)
2033     {
2034     case MSG_SORT_RULE_ACSCEND_BOOL:
2035                 pSort->bAscending = value;
2036                 break;
2037     default:
2038                 err = MSG_ERR_UNKNOWN;
2039                 break;
2040     }
2041         return err;
2042 }
2043
2044 int msg_sendopt_set_struct_handle(msg_struct_s *msg_struct, int field, msg_struct_s *value)
2045 {
2046         msg_error_t err =  MSG_SUCCESS;
2047         if(!msg_struct || !value)
2048                 return MSG_ERR_NULL_POINTER;
2049
2050         MSG_SENDINGOPT_S *sendopt = (MSG_SENDINGOPT_S *)msg_struct->data;
2051         msg_struct_s *pTmp = NULL;
2052
2053         switch(field)
2054         {
2055         case MSG_SEND_OPT_MMS_OPT_HND:
2056                 pTmp = (msg_struct_s *)sendopt->mmsSendOpt;
2057                 memcpy(pTmp->data, value->data, sizeof(MMS_SENDINGOPT_INFO_S));
2058                 break;
2059         case MSG_SEND_OPT_SMS_OPT_HND:
2060                 pTmp = (msg_struct_s *)sendopt->smsSendOpt;
2061                 memcpy(pTmp->data, value->data, sizeof(SMS_SENDINGOPT_INFO_S));
2062                 break;
2063         default:
2064                 err = MSG_ERR_UNKNOWN;
2065                 break;
2066         }
2067         return err;
2068 }
2069
2070 int msg_syncml_set_struct_handle(msg_struct_s *msg_struct, int field, msg_struct_s *value)
2071 {
2072         msg_error_t err =  MSG_SUCCESS;
2073
2074         if(!msg_struct || !value)
2075                 return MSG_ERR_NULL_POINTER;
2076
2077         MSG_SYNCML_MESSAGE_S *pSync = (MSG_SYNCML_MESSAGE_S *)msg_struct->data;
2078         msg_struct_s *pTmp = NULL;
2079
2080         switch(field)
2081         {
2082         case MSG_SYNCML_INFO_MESSAGE_HND:
2083         {
2084                 pTmp = (msg_struct_s *)pSync->msg;
2085                 MSG_MESSAGE_HIDDEN_S *pSrc = (MSG_MESSAGE_HIDDEN_S *)value->data;
2086                 MSG_MESSAGE_HIDDEN_S *pDst = (MSG_MESSAGE_HIDDEN_S *)pTmp->data;
2087                 msg_message_copy_message(pSrc, pDst);
2088                 break;
2089         }
2090         default:
2091                 err = MSG_ERR_UNKNOWN;
2092                 break;
2093
2094         }
2095         return err;
2096 }
2097
2098 int msg_thread_index_set_struct_handle(msg_struct_s *msg_struct, int field, msg_struct_s *value)
2099 {
2100         msg_error_t err =  MSG_SUCCESS;
2101
2102         if(!msg_struct || !value)
2103                 return MSG_ERR_NULL_POINTER;
2104
2105         MSG_THREAD_LIST_INDEX_INFO_S *pIndex = (MSG_THREAD_LIST_INDEX_INFO_S *)msg_struct->data;
2106         msg_struct_s *pTmp = NULL;
2107
2108         switch(field)
2109         {
2110         case MSG_THREAD_LIST_INDEX_ADDR_INFO_HND:
2111                 pTmp = (msg_struct_s *)pIndex->msgAddrInfo;
2112                 memcpy(pTmp->data, value->data, sizeof(MSG_ADDRESS_INFO_S));
2113                 break;
2114         default:
2115                 err = MSG_ERR_UNKNOWN;
2116                 break;
2117
2118         }
2119         return err;
2120 }
2121
2122 int msg_address_info_set_int(void *addrinfo, int field, int value)
2123 {
2124         msg_error_t err =  MSG_SUCCESS;
2125         if(!addrinfo)
2126                 return MSG_ERR_NULL_POINTER;
2127
2128         MSG_ADDRESS_INFO_S *pAddr = (MSG_ADDRESS_INFO_S *)addrinfo;
2129         switch(field)
2130         {
2131         case MSG_ADDRESS_INFO_ADDRESS_TYPE_INT:
2132                 pAddr->addressType = value;
2133                 break;
2134         case MSG_ADDRESS_INFO_RECIPIENT_TYPE_INT:
2135                 pAddr->recipientType = value;
2136                 break;
2137         case MSG_ADDRESS_INFO_CONTACT_ID_INT:
2138                 pAddr->contactId = value;
2139                 break;
2140         default:
2141                 err = MSG_ERR_UNKNOWN;
2142         break;
2143         }
2144
2145         return err;
2146 }
2147
2148
2149 int msg_mms_sendopt_set_int(void *opt_info, int field, int value)
2150 {
2151         msg_error_t err =  MSG_SUCCESS;
2152         if(!opt_info)
2153                 return MSG_ERR_NULL_POINTER;
2154
2155         MMS_SENDINGOPT_S *pOpt = (MMS_SENDINGOPT_S *)opt_info;
2156         switch(field)
2157         {
2158         case MSG_MMS_SENDOPTION_EXPIRY_TIME_INT:
2159                 pOpt->expiryTime = value;
2160                 break;
2161         case MSG_MMS_SENDOPTION_DELIVERY_TIME_INT:
2162                 pOpt->deliveryTime = value;
2163                 break;
2164         case MSG_MMS_SENDOPTION_PRIORITY_INT:
2165                 pOpt->priority = value;
2166                 break;
2167         default:
2168                 err = MSG_ERR_UNKNOWN;
2169         break;
2170         }
2171
2172         return err;
2173 }
2174
2175 int msg_reject_message_set_int(void *msg_info, int field, int value)
2176 {
2177         msg_error_t err =  MSG_SUCCESS;
2178         if(!msg_info)
2179                 return MSG_ERR_NULL_POINTER;
2180
2181         MSG_REJECT_MSG_INFO_S *pMsg = (MSG_REJECT_MSG_INFO_S *)msg_info;
2182         switch(field)
2183         {
2184         case MSG_REJECT_MESSAGE_MSGID_INT:
2185                 pMsg->msgId = value;
2186                 break;
2187         case MSG_REJECT_MESSAGE_DISPLAY_TIME_INT:
2188                 pMsg->displayTime = value;
2189                 break;
2190         default:
2191                 err = MSG_ERR_UNKNOWN;
2192         break;
2193         }
2194
2195         return err;
2196 }
2197
2198 int msg_address_info_set_str(void *addr_info, int field, char *value, int size)
2199 {
2200         msg_error_t err =  MSG_SUCCESS;
2201         if(!addr_info || !value)
2202                 return MSG_ERR_NULL_POINTER;
2203     MSG_ADDRESS_INFO_S *pAddr = (MSG_ADDRESS_INFO_S *)addr_info;
2204     int _len = 0;
2205
2206     switch(field)
2207     {
2208     case MSG_ADDRESS_INFO_ADDRESS_VALUE_STR:
2209         (size > MAX_ADDRESS_VAL_LEN)? _len = MAX_ADDRESS_VAL_LEN : _len = size;
2210         memset(pAddr->addressVal, 0x00, sizeof(pAddr->addressVal));
2211                 strncpy(pAddr->addressVal, value, _len);
2212                 break;
2213     case MSG_ADDRESS_INFO_DISPLAYNAME_STR:
2214         (size > MAX_DISPLAY_NAME_LEN)? _len = MAX_DISPLAY_NAME_LEN : _len = size;
2215         memset(pAddr->displayName, 0x00, sizeof(pAddr->displayName));
2216                 strncpy(pAddr->displayName, value, _len);
2217                 break;
2218     default:
2219                 err = MSG_ERR_UNKNOWN;
2220                 break;
2221     }
2222
2223         return err;
2224 }
2225 int msg_reject_message_set_str(void *msg_info, int field, char *value, int size)
2226 {
2227         msg_error_t err =  MSG_SUCCESS;
2228         if(!msg_info || !value)
2229                 return MSG_ERR_NULL_POINTER;
2230     MSG_REJECT_MSG_INFO_S *pMsg = (MSG_REJECT_MSG_INFO_S *)msg_info;
2231     int _len = 0;
2232     (size > MAX_MSG_TEXT_LEN)? _len = MAX_MSG_TEXT_LEN : _len = size;
2233     switch(field)
2234     {
2235     case MSG_REJECT_MESSAGE_MSGTEXT_STR:
2236                 strncpy(pMsg->msgText, value, _len);
2237                 break;
2238     default:
2239                 err = MSG_ERR_UNKNOWN;
2240                 break;
2241     }
2242
2243         return err;
2244 }
2245
2246 int msg_mms_sendopt_set_bool(void *option, int field, bool value)
2247 {
2248         msg_error_t err =  MSG_SUCCESS;
2249         if(!option)
2250                 return MSG_ERR_NULL_POINTER;
2251
2252     MMS_SENDINGOPT_S *pOpt = (MMS_SENDINGOPT_S *)option;
2253     switch(field)
2254     {
2255     case MSG_MMS_SENDOPTION_READ_REQUEST_BOOL:
2256                 pOpt->bReadReq = value;
2257                 break;
2258     case MSG_MMS_SENDOPTION_DELIVERY_CUSTOMTIME_BOOL:
2259                 pOpt->bUseDeliveryCustomTime = value;
2260                 break;
2261     default:
2262                 err = MSG_ERR_UNKNOWN;
2263                 break;
2264     }
2265         return err;
2266 }
2267
2268 int msg_sms_sendopt_set_bool(void *option, int field, bool value)
2269 {
2270         msg_error_t err =  MSG_SUCCESS;
2271         if(!option)
2272                 return MSG_ERR_NULL_POINTER;
2273
2274     SMS_SENDINGOPT_S *pOpt = (SMS_SENDINGOPT_S *)option;
2275     switch(field)
2276     {
2277     case MSG_SMS_SENDOPT_REPLYPATH_BOOL:
2278                 pOpt->bReplyPath = value;
2279                 break;
2280     default:
2281                 err = MSG_ERR_UNKNOWN;
2282                 break;
2283     }
2284         return err;
2285 }