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_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_delete_msgs_by_list(msg_handle_t handle, msg_id_list_s *msg_id_list)
 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->deleteMessagesByList(msg_id_list);
 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_folder(msg_handle_t handle, msg_message_id_t msg_id, msg_folder_id_t dest_folder_id)
 247 {
 248         msg_error_t err =  MSG_SUCCESS;
 249
 250         if (handle == NULL)
 251         {
 252                 return -EINVAL;
 253         }
 254
 255         MsgHandle* pHandle = (MsgHandle*)handle;
 256
 257         try
 258         {
 259                 err = pHandle->moveMessageToFolder(msg_id, dest_folder_id);
 260         }
 261         catch (MsgException& e)
 262         {
 263                 MSG_FATAL("%s", e.what());
 264                 return MSG_ERR_STORAGE_ERROR;
 265         }
 266
 267         return err;
 268 }
 269
 270
 271 EXPORT_API int msg_move_msg_to_storage(msg_handle_t handle, msg_message_id_t msg_id, msg_storage_id_t storage_id)
 272 {
 273         msg_error_t err =  MSG_SUCCESS;
 274
 275         if (handle == NULL)
 276         {
 277                 return -EINVAL;
 278         }
 279
 280         if (storage_id != MSG_STORAGE_PHONE && storage_id != MSG_STORAGE_SIM)
 281         {
 282                 MSG_FATAL("unsupported storage [%d]", storage_id);
 283                 return MSG_ERR_INVALID_PARAMETER;
 284         }
 285
 286         MsgHandle* pHandle = (MsgHandle*)handle;
 287
 288         try
 289         {
 290                 err = pHandle->moveMessageToStorage(msg_id, storage_id);
 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_message(msg_handle_t handle, msg_folder_id_t folder_id, msg_struct_t count_info)
 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         msg_struct_s *pStruct = (msg_struct_s *)count_info;
 313         try
 314         {
 315                 err = pHandle->countMessage(folder_id, (MSG_COUNT_INFO_S *)pStruct->data);
 316         }
 317         catch (MsgException& e)
 318         {
 319                 MSG_FATAL("%s", e.what());
 320                 return MSG_ERR_STORAGE_ERROR;
 321         }
 322
 323         return err;
 324 }
 325
 326
 327 EXPORT_API int msg_count_msg_by_type(msg_handle_t handle, msg_message_type_t msg_type, int *msg_count)
 328 {
 329         msg_error_t err =  MSG_SUCCESS;
 330
 331         if (handle == NULL)
 332         {
 333                 return -EINVAL;
 334         }
 335
 336         MsgHandle* pHandle = (MsgHandle*)handle;
 337
 338         MSG_MESSAGE_TYPE_S msgType = {0};
 339
 340         if (msg_type == MSG_TYPE_SMS)
 341         {
 342                 msgType.mainType = MSG_SMS_TYPE;
 343                 msgType.subType = MSG_NORMAL_SMS;
 344         }
 345         else if (msg_type == MSG_TYPE_SMS_WAPPUSH)
 346         {
 347                 msgType.mainType = MSG_SMS_TYPE;
 348                 msgType.subType = MSG_WAP_SI_SMS;
 349         }
 350         else if (msg_type == MSG_TYPE_MMS)
 351         {
 352                 msgType.mainType = MSG_MMS_TYPE;
 353                 msgType.subType = MSG_SENDREQ_MMS;
 354         }
 355
 356         try
 357         {
 358                 err = pHandle->countMsgByType(&msgType, msg_count);
 359         }
 360         catch (MsgException& e)
 361         {
 362                 MSG_FATAL("%s", e.what());
 363                 return MSG_ERR_STORAGE_ERROR;
 364         }
 365
 366         return err;
 367 }
 368
 369
 370 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)
 371 {
 372         msg_error_t err =  MSG_SUCCESS;
 373
 374         if (handle == NULL || addr_info == NULL)
 375         {
 376                 return -EINVAL;
 377         }
 378
 379         MsgHandle* pHandle = (MsgHandle*)handle;
 380         msg_struct_s *pAddr = (msg_struct_s *)addr_info;
 381         msg_struct_s *pCount = (msg_struct_s *)msg_thread_count_list;
 382
 383         try
 384         {
 385                 err = pHandle->countMsgByContact((MSG_THREAD_LIST_INDEX_INFO_S *)pAddr->data, (MSG_THREAD_COUNT_INFO_S *)pCount->data);
 386         }
 387         catch (MsgException& e)
 388         {
 389                 MSG_FATAL("%s", e.what());
 390                 return MSG_ERR_STORAGE_ERROR;
 391         }
 392
 393         return err;
 394 }
 395
 396
 397 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)
 398 {
 399         msg_error_t err =  MSG_SUCCESS;
 400
 401         if (handle == NULL || !opq_msg)
 402         {
 403                 MSG_FATAL("handle or opq_msg is NULL");
 404                 return -EINVAL;
 405         }
 406
 407         MsgHandle* pHandle = (MsgHandle*)handle;
 408
 409         msg_struct_s *pMsgStruct = (msg_struct_s *)opq_msg;
 410         msg_struct_s *pStruct = (msg_struct_s *)send_opt;
 411
 412         try
 413         {
 414                 err = pHandle->getMessage(msg_id, (MSG_MESSAGE_HIDDEN_S *)pMsgStruct->data, (MSG_SENDINGOPT_S *)pStruct->data);
 415         }
 416         catch (MsgException& e)
 417         {
 418                 MSG_FATAL("%s", e.what());
 419                 return MSG_ERR_STORAGE_ERROR;
 420         }
 421
 422         return err;
 423 }
 424
 425 EXPORT_API int msg_get_vobject_data(msg_handle_t handle, msg_message_id_t msg_id, void** result_data)
 426 {
 427         msg_error_t err =  MSG_SUCCESS;
 428
 429         if (handle == NULL || result_data == NULL)
 430         {
 431                 MSG_FATAL("handle or result_data is NULL");
 432                 return -EINVAL;
 433         }
 434
 435         MsgHandle* pHandle = (MsgHandle*)handle;
 436
 437         try
 438         {
 439                 err = pHandle->getVobject(msg_id, result_data);
 440         }
 441         catch (MsgException& e)
 442         {
 443                 MSG_FATAL("%s", e.what());
 444                 return MSG_ERR_STORAGE_ERROR;
 445         }
 446
 447         return err;
 448 }
 449 EXPORT_API int msg_get_conversation(msg_handle_t handle, msg_message_id_t msg_id, msg_struct_t conv)
 450 {
 451         msg_error_t err =  MSG_SUCCESS;
 452
 453         if (handle == NULL || !conv)
 454         {
 455                 MSG_FATAL("handle or opq_msg is NULL");
 456                 return -EINVAL;
 457         }
 458
 459         MsgHandle* pHandle = (MsgHandle*)handle;
 460
 461         msg_struct_s *pMsgStruct = (msg_struct_s *)conv;
 462         try
 463         {
 464                 err = pHandle->getConversationViewItem(msg_id, (MSG_CONVERSATION_VIEW_S *)pMsgStruct->data);
 465         }
 466         catch (MsgException& e)
 467         {
 468                 MSG_FATAL("%s", e.what());
 469                 return MSG_ERR_STORAGE_ERROR;
 470         }
 471
 472         return err;
 473 }
 474
 475 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)
 476 {
 477         msg_error_t err =  MSG_SUCCESS;
 478
 479         if (handle == NULL)
 480         {
 481                 return -EINVAL;
 482         }
 483
 484         MsgHandle* pHandle = (MsgHandle*)handle;
 485         msg_struct_s *pStruct = (msg_struct_s *)sort_rule;
 486
 487         try
 488         {
 489                 if (sort_rule == NULL)
 490                 {
 491                         MSG_SORT_RULE_S sortRule = {0};
 492
 493                         sortRule.sortType = MSG_SORT_BY_READ_STATUS;
 494                         sortRule.bAscending = true;
 495
 496                         err = pHandle->getFolderViewList(folder_id, &sortRule, msg_folder_view_list);
 497                 }
 498                 else
 499                 {
 500                 err = pHandle->getFolderViewList(folder_id, (MSG_SORT_RULE_S *)pStruct->data, msg_folder_view_list);
 501         }
 502         }
 503         catch (MsgException& e)
 504         {
 505                 MSG_FATAL("%s", e.what());
 506                 return MSG_ERR_STORAGE_ERROR;
 507         }
 508
 509         return err;
 510 }
 511
 512
 513 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)
 514 {
 515         msg_error_t err =  MSG_SUCCESS;
 516
 517         if (handle == NULL)
 518         {
 519                 return -EINVAL;
 520         }
 521
 522         MsgHandle* pHandle = (MsgHandle*)handle;
 523         msg_struct_s *pStruct =(msg_struct_s *)sort_rule;
 524
 525         try
 526         {
 527                 if (sort_rule == NULL)
 528                 {
 529                         MSG_SORT_RULE_S sortRule = {0};
 530
 531                         sortRule.sortType = MSG_SORT_BY_THREAD_DATE;
 532                         sortRule.bAscending = false;
 533
 534                         err = pHandle->getThreadViewList(&sortRule, msg_thread_view_list);
 535                 }
 536                 else
 537                 {
 538                         err = pHandle->getThreadViewList((MSG_SORT_RULE_S *)pStruct->data, msg_thread_view_list);
 539                 }
 540         }
 541         catch (MsgException& e)
 542         {
 543                 MSG_FATAL("%s", e.what());
 544                 return MSG_ERR_STORAGE_ERROR;
 545         }
 546
 547         return err;
 548 }
 549
 550
 551 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)
 552 {
 553         msg_error_t err =  MSG_SUCCESS;
 554
 555         if (handle == NULL)
 556         {
 557                 return -EINVAL;
 558         }
 559
 560         MsgHandle* pHandle = (MsgHandle*)handle;
 561
 562         try
 563         {
 564                 err = pHandle->getConversationViewList(thread_id, msg_conv_view_list);
 565         }
 566         catch (MsgException& e)
 567         {
 568                 MSG_FATAL("%s", e.what());
 569                 return MSG_ERR_STORAGE_ERROR;
 570         }
 571
 572         return err;
 573 }
 574
 575
 576 EXPORT_API int msg_delete_thread_message_list(msg_handle_t handle, msg_thread_id_t thread_id, bool include_protected_msg)
 577 {
 578         msg_error_t err =  MSG_SUCCESS;
 579
 580         if (handle == NULL)
 581         {
 582                 return -EINVAL;
 583         }
 584
 585         MsgHandle* pHandle = (MsgHandle*)handle;
 586
 587         try
 588         {
 589                 err = pHandle->deleteThreadMessageList(thread_id, include_protected_msg);
 590         }
 591         catch (MsgException& e)
 592         {
 593                 MSG_FATAL("%s", e.what());
 594                 return MSG_ERR_STORAGE_ERROR;
 595         }
 596
 597         return err;
 598 }
 599
 600
 601 EXPORT_API int msg_add_folder(msg_handle_t handle, const msg_struct_t folder_info)
 602 {
 603         msg_error_t err =  MSG_SUCCESS;
 604
 605         if (handle == NULL || folder_info == NULL)
 606         {
 607                 return -EINVAL;
 608         }
 609
 610         MsgHandle* pHandle = (MsgHandle*)handle;
 611         msg_struct_s *pStruct = (msg_struct_s *)folder_info;
 612
 613         try
 614         {
 615                 err = pHandle->addFolder((MSG_FOLDER_INFO_S *)pStruct->data);
 616         }
 617         catch (MsgException& e)
 618         {
 619                 MSG_FATAL("%s", e.what());
 620                 return MSG_ERR_STORAGE_ERROR;
 621         }
 622
 623         return err;
 624 }
 625
 626
 627 EXPORT_API int msg_update_folder(msg_handle_t handle, const msg_struct_t folder_info)
 628 {
 629         msg_error_t err =  MSG_SUCCESS;
 630
 631         if (handle == NULL || folder_info == NULL)
 632         {
 633                 return -EINVAL;
 634         }
 635
 636         MsgHandle* pHandle = (MsgHandle*)handle;
 637         msg_struct_s *pStruct = (msg_struct_s *)folder_info;
 638
 639         try
 640         {
 641                 err = pHandle->updateFolder((MSG_FOLDER_INFO_S *)pStruct->data);
 642         }
 643         catch (MsgException& e)
 644         {
 645                 MSG_FATAL("%s", e.what());
 646                 return MSG_ERR_STORAGE_ERROR;
 647         }
 648
 649         return err;
 650 }
 651
 652
 653 EXPORT_API int msg_delete_folder(msg_handle_t handle, msg_folder_id_t folder_id)
 654 {
 655         msg_error_t err =  MSG_SUCCESS;
 656
 657         if (handle == NULL)
 658         {
 659                 return -EINVAL;
 660         }
 661
 662         MsgHandle* pHandle = (MsgHandle*)handle;
 663
 664         try
 665         {
 666                 err = pHandle->deleteFolder(folder_id);
 667         }
 668         catch (MsgException& e)
 669         {
 670                 MSG_FATAL("%s", e.what());
 671                 return MSG_ERR_STORAGE_ERROR;
 672         }
 673
 674         return err;
 675 }
 676
 677
 678 EXPORT_API int msg_get_folder_list(msg_handle_t handle, msg_struct_list_s *folder_list)
 679 {
 680         msg_error_t err =  MSG_SUCCESS;
 681
 682         if (handle == NULL)
 683         {
 684                 return -EINVAL;
 685         }
 686
 687         MsgHandle* pHandle = (MsgHandle*)handle;
 688
 689         try
 690         {
 691                 err = pHandle->getFolderList(folder_list);
 692         }
 693         catch (MsgException& e)
 694         {
 695                 MSG_FATAL("%s", e.what());
 696                 return MSG_ERR_STORAGE_ERROR;
 697         }
 698
 699         return err;
 700 }
 701
 702
 703 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)
 704 {
 705         if (handle == NULL)
 706         {
 707                 MSG_DEBUG("Handle is NULL");
 708                 return -EINVAL;
 709         }
 710
 711         if (folder_id >= MSG_MAX_FOLDER_ID)
 712         {
 713                 MSG_DEBUG("folderId is invalid [%d]", folder_id);
 714                 return -EINVAL;
 715         }
 716
 717         MSG_DEBUG("type : %d, folder : %d, num_msg : %d", msg_type, folder_id, num_msg);
 718
 719         int err = 0;
 720         MSG_SENDINGOPT_S sendingOpt = {0};
 721         sendingOpt.bSetting = false;
 722
 723         char strMsg[20] = {0};
 724         char prefix[10] ="0103001";
 725 //      int postfix = 8111;
 726         int postfix = 0;
 727
 728         srand(getpid());
 729
 730         msg_struct_s *msg_s = NULL;
 731         msg_struct_s *addr_s = NULL;
 732         MSG_MESSAGE_HIDDEN_S *msgInfo = NULL;
 733         MSG_ADDRESS_INFO_S *addrInfo = NULL;
 734
 735         for (unsigned int i = 0; i < num_msg; i++)
 736         {
 737                 msg_s = (msg_struct_s *)msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
 738                 msgInfo = (MSG_MESSAGE_HIDDEN_S *)msg_s->data;
 739
 740                 msgInfo->folderId = folder_id;
 741
 742                 if (msg_type == MSG_TYPE_MMS)
 743                 {
 744                         msgInfo->mainType = MSG_MMS_TYPE;
 745                         msgInfo->subType = MSG_SENDREQ_MMS;
 746                 }
 747                 else
 748                 {
 749                         msgInfo->mainType = MSG_SMS_TYPE;
 750                         msgInfo->subType = MSG_NORMAL_SMS;
 751
 752                         snprintf(strMsg, sizeof(strMsg), "test msg %d", i);
 753                         msgInfo->dataSize = strlen(strMsg);
 754                         msgInfo->pData = (void*)new char[msgInfo->dataSize+1];
 755             memcpy((char *)msgInfo->pData, strMsg, msgInfo->dataSize);
 756             ((char*) msgInfo->pData)[msgInfo->dataSize] = '\0';
 757                 }
 758
 759                 msgInfo->storageId = MSG_STORAGE_PHONE;
 760
 761                 msgInfo->addr_list->nCount = 1;
 762
 763                 addr_s = (msg_struct_s *)msgInfo->addr_list->msg_struct_info[0];
 764
 765                 addrInfo = (MSG_ADDRESS_INFO_S *)addr_s->data;
 766
 767                 addrInfo->addressType = MSG_ADDRESS_TYPE_PLMN;
 768                 postfix = rand()%10000;
 769                 snprintf(addrInfo->addressVal, MAX_ADDRESS_VAL_LEN+1, "%s%04d", prefix, postfix);
 770
 771                 addrInfo->recipientType = MSG_RECIPIENTS_TYPE_TO;
 772
 773                 time(&(msgInfo->displayTime));
 774
 775                 msgInfo->networkStatus = MSG_NETWORK_NOT_SEND;
 776                 msgInfo->bRead = false;
 777                 msgInfo->bProtected = false;
 778                 msgInfo->priority = MSG_MESSAGE_PRIORITY_NORMAL;
 779
 780                 if (folder_id == MSG_OUTBOX_ID || folder_id == MSG_SENTBOX_ID)
 781                         msgInfo->direction = MSG_DIRECTION_TYPE_MO;
 782                 else
 783                         msgInfo->direction = MSG_DIRECTION_TYPE_MT;
 784
 785                 if (msg_type == MSG_TYPE_MMS)
 786                 {
 787                         snprintf(msgInfo->subject, MAX_SUBJECT_LEN+1, "subject %d", i);
 788
 789                         if(folder_id == MSG_INBOX_ID) msgInfo->networkStatus = MSG_NETWORK_RETRIEVE_SUCCESS;
 790
 791                         //MMS_MESSAGE_DATA_S* mms_data;
 792                         //MMS_PAGE_S* page[2];
 793                         //MMS_MEDIA_S* media[5];
 794
 795 //                      mms_data = msg_mms_create_message();
 796
 797 //                      msg_mms_set_rootlayout(mms_data, 100, 100, 0xffffff);
 798 //                      msg_mms_add_region(mms_data, "Image", 0, 50, 100, 50, 0xffffff);
 799 //                      msg_mms_add_region(mms_data, "Text", 0, 0, 100, 50, 0xffffff);
 800
 801                         //------------>  1st Slide Composing
 802 //                      page[0] = msg_mms_add_page(mms_data, 5440);
 803
 804 //                      media[0] = msg_mms_add_media(page[0], MMS_SMIL_MEDIA_IMG, "Image", (char*)"/opt/etc/msg-service/P091120_104633.jpg");
 805 //                      media[1] = msg_mms_add_media(page[0], MMS_SMIL_MEDIA_AUDIO, NULL, (char*)"/opt/etc/msg-service/audio.amr");
 806 //                      media[2] = msg_mms_add_media(page[0], MMS_SMIL_MEDIA_TEXT, "Text", (char*)"/opt/etc/msg-service/Temp0_2.txt");
 807 //                      media[2]->sMedia.sText.nColor = 0x000000;
 808 //                      media[2]->sMedia.sText.nSize = MMS_SMIL_FONT_SIZE_NORMAL;
 809 //                      media[2]->sMedia.sText.bBold = true;
 810
 811                         //------------>  2nd Slide Composing
 812 //                      page[1] = msg_mms_add_page(mms_data, 4544);
 813
 814 //                      media[3] = msg_mms_add_media(page[1], MMS_SMIL_MEDIA_TEXT, "Text", (char*)"/opt/etc/msg-service/Temp1_0.txt");
 815 //                      media[3]->sMedia.sText.nColor = 0x000000;
 816 //                      media[3]->sMedia.sText.nSize = MMS_SMIL_FONT_SIZE_NORMAL;
 817 //                      media[3]->sMedia.sText.bItalic = true;
 818 //                      media[4] = msg_mms_add_media(page[1], MMS_SMIL_MEDIA_VIDEO, "Text", (char*)"/opt/etc/msg-service/V091120_104905.3gp");
 819 //                      strncpy(media[4]->szAlt, "Video Load Fail", MAX_SMIL_ALT_LEN-1);
 820
 821                         //FIXME msg_mms_set_message_body((msg_message_t)&msgInfo, mms_data);
 822
 823 //                      msg_mms_destroy_message(mms_data);
 824                 }
 825
 826                 //err = msg_add_message(handle, (msg_message_t)&msgInfo, &sendingOpt);
 827                 try
 828                 {
 829                         MsgHandle* pHandle = (MsgHandle*)handle;
 830                         err = pHandle->addMessage(msgInfo, &sendingOpt);
 831                 }
 832                 catch (MsgException& e)
 833                 {
 834                         MSG_FATAL("%s", e.what());
 835                         msg_release_struct((msg_struct_t *)&msg_s);
 836                         return MSG_ERR_STORAGE_ERROR;
 837                 }
 838
 839                 if (msg_type == MSG_TYPE_MMS && msgInfo->pMmsData) //free pMmsData directly. It is added to enhance performance
 840                         delete [] static_cast<char*>(msgInfo->pMmsData);
 841
 842                 msg_release_struct((msg_struct_t *)&msg_s);
 843
 844                 if (err < 0)
 845                 {
 846                         MSG_DEBUG("err [%d]", err);
 847                         return err;
 848                 }
 849         }
 850
 851         return MSG_SUCCESS;
 852 }
 853
 854
 855 EXPORT_API int msg_generate_sms(msg_handle_t handle, msg_folder_id_t folder_id, unsigned int num_msg)
 856 {
 857         MSG_DEBUG("folder %d, num_msg %d", folder_id, num_msg);
 858
 859         if (handle == NULL)
 860         {
 861                 MSG_DEBUG("Handle is NULL");
 862                 return -EINVAL;
 863         }
 864
 865         if (folder_id >= MSG_MAX_FOLDER_ID)
 866         {
 867                 MSG_DEBUG("folderId is invalid");
 868                 return -EINVAL;
 869         }
 870
 871         int err = 0;
 872         char strMsg[20] = {0};
 873         char prefix[10] ="0103001";
 874         int postfix = 0;
 875
 876         MSG_SENDINGOPT_S sendingOpt = {0};
 877         sendingOpt.bSetting = false;
 878
 879         srand(getpid());
 880
 881         msg_struct_s *msg_s = NULL;
 882         msg_struct_s *addr_s = NULL;
 883         MSG_MESSAGE_HIDDEN_S *msgInfo = NULL;
 884         MSG_ADDRESS_INFO_S *addrInfo = NULL;
 885
 886         for (unsigned int i = 0; i < num_msg; i++)
 887         {
 888                 msg_s = (msg_struct_s *)msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
 889                 msgInfo = (MSG_MESSAGE_HIDDEN_S *)msg_s->data;
 890
 891                 msgInfo->msgId  = 0; // It should be set 0
 892                 msgInfo->folderId = folder_id;
 893
 894                 msgInfo->mainType = MSG_SMS_TYPE;
 895                 msgInfo->subType = 0;
 896
 897                 msgInfo->storageId = MSG_STORAGE_PHONE;
 898
 899                 snprintf(strMsg, sizeof(strMsg), "test %d", i);
 900                 msgInfo->dataSize = strlen(strMsg);
 901                 msgInfo->pData = strMsg;
 902
 903                 msgInfo->addr_list->nCount = 1;
 904
 905                 addr_s = (msg_struct_s *)msgInfo->addr_list->msg_struct_info[0];
 906
 907                 addrInfo = (MSG_ADDRESS_INFO_S *)addr_s->data;
 908
 909                 addrInfo->addressType = MSG_ADDRESS_TYPE_PLMN;
 910                 postfix = rand()%10000;
 911                 snprintf(addrInfo->addressVal, MAX_ADDRESS_VAL_LEN+1, "%s%04d", prefix, postfix);
 912
 913                 addrInfo->recipientType = MSG_RECIPIENTS_TYPE_TO;
 914
 915                 time(&(msgInfo->displayTime));
 916
 917                 msgInfo->networkStatus = MSG_NETWORK_NOT_SEND;
 918                 msgInfo->bRead = false;
 919                 msgInfo->bProtected = false;
 920                 msgInfo->priority = MSG_MESSAGE_PRIORITY_NORMAL;
 921                 msgInfo->direction = MSG_DIRECTION_TYPE_MO;
 922
 923 //              err = msg_add_message(handle, (msg_message_t) &msgInfo, &sendingOpt);
 924                 try
 925                 {
 926                         MsgHandle* pHandle = (MsgHandle*)handle;
 927                         err = pHandle->addMessage(msgInfo, &sendingOpt);
 928                 }
 929                 catch (MsgException& e)
 930                 {
 931                         MSG_FATAL("%s", e.what());
 932                         msg_release_struct((msg_struct_t *)&msg_s);
 933                         return MSG_ERR_STORAGE_ERROR;
 934                 }
 935
 936                 msg_release_struct((msg_struct_t *)&msg_s);
 937
 938                 if (err < 0)
 939                 {
 940                         MSG_DEBUG("err [%d]", err);
 941                         return err;
 942                 }
 943         }
 944
 945         return MSG_SUCCESS;
 946 }
 947
 948
 949 EXPORT_API int msg_get_quick_panel_data(msg_handle_t handle, msg_quickpanel_type_t type, msg_struct_t opq_msg)
 950 {
 951         msg_error_t err =  MSG_SUCCESS;
 952
 953         if (handle == NULL || !opq_msg )
 954         {
 955                 MSG_FATAL("handle or opq_msg is NULL");
 956                 return -EINVAL;
 957         }
 958
 959         MsgHandle* pHandle = (MsgHandle*)handle;
 960         msg_struct_s *pMsg = (msg_struct_s *)opq_msg;
 961
 962         try
 963         {
 964                 err = pHandle->getQuickPanelData(type, (MSG_MESSAGE_HIDDEN_S *)pMsg->data);
 965         }
 966         catch (MsgException& e)
 967         {
 968                 MSG_FATAL("%s", e.what());
 969                 return MSG_ERR_STORAGE_ERROR;
 970         }
 971
 972         return err;
 973 }
 974
 975
 976 EXPORT_API int msg_reset_database(msg_handle_t handle)
 977 {
 978         msg_error_t err =  MSG_SUCCESS;
 979
 980         if (handle == NULL)
 981         {
 982                 return -EINVAL;
 983         }
 984
 985         MsgHandle* pHandle = (MsgHandle*)handle;
 986
 987         try
 988         {
 989                 err = pHandle->resetDatabase();
 990         }
 991         catch (MsgException& e)
 992         {
 993                 MSG_FATAL("%s", e.what());
 994                 return MSG_ERR_STORAGE_ERROR;
 995         }
 996
 997         return err;
 998 }
 999
1000
1001 EXPORT_API int msg_get_mem_size(msg_handle_t handle, unsigned int* memsize)
1002 {
1003         msg_error_t err =  MSG_SUCCESS;
1004
1005         if (handle == NULL)
1006         {
1007                 return -EINVAL;
1008         }
1009
1010         MsgHandle* pHandle = (MsgHandle*)handle;
1011
1012         try
1013         {
1014                 err = pHandle->getMemSize(memsize);
1015         }
1016         catch (MsgException& e)
1017         {
1018                 MSG_FATAL("%s", e.what());
1019                 return MSG_ERR_STORAGE_ERROR;
1020         }
1021
1022         return err;
1023
1024 }
1025
1026 EXPORT_API int msg_backup_message(msg_handle_t handle, msg_message_backup_type_t type, const char *backup_filepath)
1027 {
1028         msg_error_t err =  MSG_SUCCESS;
1029
1030         if (handle == NULL || backup_filepath == NULL)
1031         {
1032                 return -EINVAL;
1033         }
1034
1035         MsgHandle* pHandle = (MsgHandle*)handle;
1036
1037         try
1038         {
1039                 err = pHandle->backupMessage(type, backup_filepath);
1040         }
1041         catch (MsgException& e)
1042         {
1043                 MSG_FATAL("%s", e.what());
1044                 return MSG_ERR_STORAGE_ERROR;
1045         }
1046
1047         return err;
1048 }
1049
1050
1051 EXPORT_API int msg_restore_message(msg_handle_t handle, const char *backup_filepath)
1052 {
1053         msg_error_t err =  MSG_SUCCESS;
1054
1055         if (handle == NULL || backup_filepath == NULL)
1056         {
1057                 return -EINVAL;
1058         }
1059
1060         MsgHandle* pHandle = (MsgHandle*)handle;
1061
1062         try
1063         {
1064                 err = pHandle->restoreMessage(backup_filepath);
1065         }
1066         catch (MsgException& e)
1067         {
1068                 MSG_FATAL("%s", e.what());
1069                 return MSG_ERR_STORAGE_ERROR;
1070         }
1071
1072         return err;
1073 }
1074
1075
1076 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)
1077 {
1078         msg_error_t err =  MSG_SUCCESS;
1079
1080         if (handle == NULL || search_string == NULL)
1081         {
1082                 return -EINVAL;
1083         }
1084
1085         if (strlen(search_string) <= 0 || strlen(search_string) > MAX_MSG_TEXT_LEN)
1086         {
1087                 return -EINVAL;
1088         }
1089
1090         MsgHandle* pHandle = (MsgHandle*)handle;
1091
1092         try
1093         {
1094                 err = pHandle->searchMessage(search_string, msg_thread_view_list);
1095         }
1096         catch (MsgException& e)
1097         {
1098                 MSG_FATAL("%s", e.what());
1099                 return MSG_ERR_STORAGE_ERROR;
1100         }
1101
1102         return err;
1103 }
1104
1105
1106 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)
1107 {
1108         msg_error_t err =  MSG_SUCCESS;
1109
1110         if (handle == NULL || msg_search_conditions == NULL)
1111         {
1112                 return -EINVAL;
1113         }
1114
1115         MsgHandle* pHandle = (MsgHandle*)handle;
1116         msg_struct_s *pStruct = (msg_struct_s *)msg_search_conditions;
1117
1118         try
1119         {
1120                 err = pHandle->searchMessage((MSG_SEARCH_CONDITION_S *)pStruct->data, offset, limit, msg_list);
1121         }
1122         catch (MsgException& e)
1123         {
1124                 MSG_FATAL("%s", e.what());
1125                 return MSG_ERR_STORAGE_ERROR;
1126         }
1127
1128         return err;
1129 }
1130
1131 EXPORT_API int msg_get_reject_msg_list(msg_handle_t handle, const char *phone_num, msg_struct_list_s *msg_reject_msg_list)
1132 {
1133         msg_error_t err =  MSG_SUCCESS;
1134
1135         if (handle == NULL)
1136         {
1137                 return -EINVAL;
1138         }
1139
1140         MsgHandle* pHandle = (MsgHandle*)handle;
1141
1142         try
1143         {
1144                 err = pHandle->getRejectMsgList(phone_num, msg_reject_msg_list);
1145         }
1146         catch (MsgException& e)
1147         {
1148                 MSG_FATAL("%s", e.what());
1149                 return MSG_ERR_STORAGE_ERROR;
1150         }
1151
1152         return err;
1153 }
1154
1155
1156 EXPORT_API int msg_reg_storage_change_callback(msg_handle_t handle, msg_storage_change_cb cb, void *user_param)
1157 {
1158         msg_error_t err =  MSG_SUCCESS;
1159
1160         if (handle == NULL || cb == NULL)
1161         {
1162                 return -EINVAL;
1163         }
1164
1165         MsgHandle* pHandle = (MsgHandle*)handle;
1166
1167         try
1168         {
1169                 err = pHandle->regStorageChangeCallback(cb, user_param);
1170         }
1171         catch (MsgException& e)
1172         {
1173                 MSG_FATAL("%s", e.what());
1174                 return MSG_ERR_CALLBACK_ERROR;
1175         }
1176
1177         return err;
1178 }
1179
1180 EXPORT_API int msg_get_report_status(msg_handle_t handle, msg_message_id_t msg_id, msg_struct_list_s *report_list)
1181 {
1182         msg_error_t err =  MSG_SUCCESS;
1183
1184         if (handle == NULL || msg_id < 1 || report_list == NULL)
1185         {
1186                 return -EINVAL;
1187         }
1188
1189         MsgHandle* pHandle = (MsgHandle*)handle;
1190
1191         try
1192         {
1193                 err = pHandle->getReportStatus(msg_id, report_list);
1194         }
1195         catch (MsgException& e)
1196         {
1197                 MSG_FATAL("%s", e.what());
1198                 return MSG_ERR_STORAGE_ERROR;
1199         }
1200
1201         return err;
1202 }
1203
1204 EXPORT_API int msg_get_address_list(msg_handle_t handle, msg_thread_id_t thread_id, msg_struct_list_s *msg_address_list)
1205 {
1206         msg_error_t err =  MSG_SUCCESS;
1207
1208         if (handle == NULL)
1209         {
1210                 return -EINVAL;
1211         }
1212
1213         MsgHandle* pHandle = (MsgHandle*)handle;
1214
1215         try
1216         {
1217                 err = pHandle->getAddressList(thread_id, msg_address_list);
1218         }
1219         catch (MsgException& e)
1220         {
1221                 MSG_FATAL("%s", e.what());
1222                 return MSG_ERR_STORAGE_ERROR;
1223         }
1224
1225         return err;
1226 }
1227
1228
1229 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)
1230 {
1231         msg_error_t err =  MSG_SUCCESS;
1232
1233         if (handle == NULL || msg_address_list->nCount < 1)
1234         {
1235                 return -EINVAL;
1236         }
1237
1238         MsgHandle* pHandle = (MsgHandle*)handle;
1239
1240         try
1241         {
1242                 err = pHandle->getThreadIdByAddress(msg_address_list, thread_id);
1243         }
1244         catch (MsgException& e)
1245         {
1246                 MSG_FATAL("%s", e.what());
1247                 return MSG_ERR_STORAGE_ERROR;
1248         }
1249
1250         return err;
1251 }
1252
1253
1254 EXPORT_API int msg_get_thread(msg_handle_t handle, msg_thread_id_t thread_id, msg_struct_t msg_thread)
1255 {
1256         msg_error_t err =  MSG_SUCCESS;
1257
1258         if (handle == NULL || msg_thread == NULL ) {
1259                 MSG_FATAL("handle or msg_thread is NULL");
1260                 return -EINVAL;
1261         }
1262
1263         MsgHandle* pHandle = (MsgHandle*)handle;
1264         msg_struct_s *msgThread = (msg_struct_s *)msg_thread;
1265         if (msgThread->type != MSG_STRUCT_THREAD_INFO) {
1266                 MSG_FATAL("Invaild type. type [%d]", msgThread->type);
1267                 return MSG_ERR_INVALID_PARAMETER;
1268         }
1269
1270         MSG_THREAD_VIEW_S* pThreadInfo = (MSG_THREAD_VIEW_S *)msgThread->data;
1271
1272         try
1273         {
1274                 err = pHandle->getThread(thread_id, pThreadInfo);
1275         }
1276         catch (MsgException& e)
1277         {
1278                 MSG_FATAL("%s", e.what());
1279                 return MSG_ERR_STORAGE_ERROR;
1280         }
1281
1282         return err;
1283 }
1284
1285
1286 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)
1287 {
1288         msg_error_t err =  MSG_SUCCESS;
1289
1290         if (handle == NULL) {
1291                 return -EINVAL;
1292         }
1293
1294         MsgHandle* pHandle = (MsgHandle*)handle;
1295
1296         try
1297         {
1298                 err = pHandle->getMessageList(folder_id, thread_id, msg_type, storage_id, msg_list);
1299         }
1300         catch (MsgException& e)
1301         {
1302                 MSG_FATAL("%s", e.what());
1303                 return MSG_ERR_STORAGE_ERROR;
1304         }
1305
1306         return err;
1307 }
1308
1309 static int msg_get_msg_type(int mainType, int subType)
1310 {
1311         if (mainType == MSG_SMS_TYPE)
1312         {
1313                 if (subType == MSG_CB_SMS)
1314                         return MSG_TYPE_SMS_CB;
1315                 else if (subType == MSG_JAVACB_SMS)
1316                         return MSG_TYPE_SMS_JAVACB;
1317                 else if (subType == MSG_WAP_SI_SMS || subType == MSG_WAP_SL_SMS)
1318                         return MSG_TYPE_SMS_WAPPUSH;
1319                 else if (subType == MSG_MWI_VOICE_SMS || subType == MSG_MWI_FAX_SMS
1320                                 || subType == MSG_MWI_EMAIL_SMS || subType == MSG_MWI_OTHER_SMS)
1321                         return MSG_TYPE_SMS_MWI;
1322                 else    if (subType == MSG_SYNCML_CP)
1323                         return MSG_TYPE_SMS_SYNCML;
1324                 else    if (subType == MSG_REJECT_SMS)
1325                         return MSG_TYPE_SMS_REJECT;
1326                 else
1327                         return MSG_TYPE_SMS;
1328         }
1329         else if (mainType == MSG_MMS_TYPE)
1330         {
1331                 if (subType == MSG_NOTIFICATIONIND_MMS)
1332                         return MSG_TYPE_MMS_NOTI;
1333                 else if (subType == MSG_SENDREQ_JAVA_MMS)
1334                         return MSG_TYPE_MMS_JAVA;
1335                 else
1336                         return MSG_TYPE_MMS;
1337         }
1338         else
1339                 return MSG_TYPE_INVALID;
1340 }
1341
1342
1343 int msg_syncml_info_get_int(void *syncml_info, int field)
1344 {
1345         int result = MSG_ERR_INVALID_PARAMETER;
1346         MSG_SYNCML_MESSAGE_S *pSync = (MSG_SYNCML_MESSAGE_S *)syncml_info;
1347         switch(field)
1348         {
1349         case MSG_SYNCML_INFO_EXTID_INT:
1350                 result = pSync->extId;
1351                 break;
1352         case MSG_SYNCML_INFO_PINCODE_INT:
1353                 result = pSync->pinCode;
1354                 break;
1355         default:
1356                 result = MSG_ERR_INVALID_PARAMETER;
1357                 break;
1358         }
1359         return result;
1360 }
1361
1362 int msg_count_info_get_int(void *count_info, int field)
1363 {
1364         int result = MSG_ERR_INVALID_PARAMETER;
1365         MSG_COUNT_INFO_S *pCount = (MSG_COUNT_INFO_S *)count_info;
1366         switch(field)
1367         {
1368         case MSG_COUNT_INFO_READ_INT:
1369                 result = pCount->nReadCnt;
1370                 break;
1371         case MSG_COUNT_INFO_UNREAD_INT:
1372                 result = pCount->nUnreadCnt;
1373                 break;
1374         case MSG_COUNT_INFO_SMS_INT:
1375                 result = pCount->nSms;
1376                 break;
1377         case MSG_COUNT_INFO_MMS_INT:
1378                 result = pCount->nMms;
1379                 break;
1380         default:
1381                 result = MSG_ERR_INVALID_PARAMETER;
1382                 break;
1383         }
1384         return result;
1385 }
1386
1387 int msg_thread_count_get_int(void *count_info, int field)
1388 {
1389         int result = MSG_ERR_INVALID_PARAMETER;
1390         MSG_THREAD_COUNT_INFO_S *pCount = (MSG_THREAD_COUNT_INFO_S *)count_info;
1391         switch(field)
1392         {
1393         case MSG_THREAD_COUNT_TOTAL_INT:
1394                 result = pCount->totalCount;
1395                 break;
1396         case MSG_THREAD_COUNT_UNREAD_INT:
1397                 result = pCount->unReadCount;
1398                 break;
1399         case MSG_THREAD_COUNT_SMS_INT:
1400                 result = pCount->smsMsgCount;
1401                 break;
1402         case MSG_THREAD_COUNT_MMS_INT:
1403                 result = pCount->mmsMsgCount;
1404                 break;
1405         default:
1406                 result = MSG_ERR_INVALID_PARAMETER;
1407                 break;
1408         }
1409         return result;
1410 }
1411
1412 int msg_thread_index_get_int(void *index_info, int field)
1413 {
1414         int result = MSG_ERR_INVALID_PARAMETER;
1415         MSG_THREAD_LIST_INDEX_S *pIndex = (MSG_THREAD_LIST_INDEX_S *)index_info;
1416         switch(field)
1417         {
1418         case MSG_THREAD_LIST_INDEX_CONTACTID_INT:
1419                 result = pIndex->contactId;
1420                 break;
1421         default:
1422                 result = MSG_ERR_INVALID_PARAMETER;
1423                 break;
1424         }
1425         return result;
1426 }
1427
1428 int msg_sortrule_get_int(void *sort_info, int field)
1429 {
1430         int result = MSG_ERR_INVALID_PARAMETER;
1431         MSG_SORT_RULE_S *pSort = (MSG_SORT_RULE_S *)sort_info;
1432         switch(field)
1433         {
1434         case MSG_SORT_RULE_SORT_TYPE_INT:
1435                 result = pSort->sortType;
1436                 break;
1437         default:
1438                 result = MSG_ERR_INVALID_PARAMETER;
1439                 break;
1440         }
1441         return result;
1442 }
1443
1444 int msg_folder_info_get_int(void *folder_info, int field)
1445 {
1446         int result = MSG_ERR_INVALID_PARAMETER;
1447         MSG_FOLDER_INFO_S *pFolder = (MSG_FOLDER_INFO_S *)folder_info;
1448         switch(field)
1449         {
1450         case MSG_FOLDER_INFO_ID_INT:
1451                 result = pFolder->folderId;
1452                 break;
1453         case MSG_FOLDER_INFO_TYPE_INT:
1454                 result = pFolder->folderType;
1455                 break;
1456         default:
1457                 result = MSG_ERR_INVALID_PARAMETER;
1458                 break;
1459         }
1460         return result;
1461 }
1462
1463 int msg_thread_info_get_int(void *data, int field)
1464 {
1465         int result = MSG_ERR_INVALID_PARAMETER;
1466         MSG_THREAD_VIEW_S *pThread = (MSG_THREAD_VIEW_S *)data;
1467
1468         switch(field)
1469         {
1470         case MSG_THREAD_ID_INT :
1471                 result = pThread->threadId;
1472                 break;
1473         case MSG_THREAD_MSG_TYPE_INT :
1474                 result = msg_get_msg_type(pThread->mainType, pThread->subType);
1475                 break;
1476         case MSG_THREAD_MSG_TIME_INT :
1477                 result = pThread->threadTime;
1478                 break;
1479         case MSG_THREAD_DIRECTION_INT :
1480                 result = pThread->direction;
1481                 break;
1482         case MSG_THREAD_UNREAD_COUNT_INT :
1483                 result = pThread->unreadCnt;
1484                 break;
1485         case MSG_THREAD_SMS_COUNT_INT :
1486                 result = pThread->smsCnt;
1487                 break;
1488         case MSG_THREAD_MMS_COUNT_INT :
1489                 result = pThread->mmsCnt;
1490                 break;
1491         default:
1492                 result = MSG_ERR_INVALID_PARAMETER;
1493                 break;
1494         }
1495         return result;
1496 }
1497
1498
1499 int msg_conv_info_get_int(void *data, int field)
1500 {
1501         int result = MSG_ERR_INVALID_PARAMETER;
1502         MSG_CONVERSATION_VIEW_S *pConv = (MSG_CONVERSATION_VIEW_S *)data;
1503
1504         switch(field)
1505         {
1506         case MSG_CONV_MSG_ID_INT :
1507                 result = pConv->msgId;
1508                 break;
1509         case MSG_CONV_MSG_THREAD_ID_INT :
1510                 result = pConv->threadId;
1511                 break;
1512         case MSG_CONV_MSG_FOLDER_ID_INT :
1513                 result = pConv->folderId;
1514                 break;
1515         case MSG_CONV_MSG_TYPE_INT :
1516                 result = msg_get_msg_type(pConv->mainType, pConv->subType);
1517                 break;
1518         case MSG_CONV_MSG_STORAGE_ID_INT :
1519                 result = pConv->storageId;
1520                 break;
1521         case MSG_CONV_MSG_DISPLAY_TIME_INT :
1522                 result = pConv->displayTime;
1523                 break;
1524         case MSG_CONV_MSG_SCHEDULED_TIME_INT :
1525                 result = pConv->scheduledTime;
1526                 break;
1527         case MSG_CONV_MSG_NETWORK_STATUS_INT :
1528                 result = pConv->networkStatus;
1529                 break;
1530         case MSG_CONV_MSG_DIRECTION_INT :
1531                 result = pConv->direction;
1532                 break;
1533         case MSG_CONV_MSG_ATTACH_COUNT_INT :
1534                 result = pConv->attachCount;
1535                 break;
1536         case MSG_CONV_MSG_TEXT_SIZE_INT :
1537                 result = pConv->textSize;
1538                 break;
1539         case MSG_CONV_MSG_PAGE_COUNT_INT :
1540                 result = pConv->pageCount;
1541                 break;
1542         default:
1543                 result = MSG_ERR_INVALID_PARAMETER;
1544                 break;
1545         }
1546         return result;
1547 }
1548
1549
1550 int msg_search_condition_get_int(void *condition_info, int field)
1551 {
1552         int result = MSG_ERR_INVALID_PARAMETER;
1553         MSG_SEARCH_CONDITION_S *pCond = (MSG_SEARCH_CONDITION_S *)condition_info;
1554         switch(field)
1555         {
1556         case MSG_SEARCH_CONDITION_FOLDERID_INT:
1557                 result = pCond->folderId;
1558                 break;
1559         case MSG_SEARCH_CONDITION_MSGTYPE_INT:
1560                 result = pCond->msgType;
1561                 break;
1562         case MSG_SEARCH_CONDITION_RESERVED_INT:
1563                 result = pCond->reserved;
1564                 break;
1565         default:
1566                 result = MSG_ERR_INVALID_PARAMETER;
1567                 break;
1568         }
1569         return result;
1570 }
1571
1572 int msg_report_status_get_int(void *report_info, int field)
1573 {
1574         int result = MSG_ERR_INVALID_PARAMETER;
1575         MSG_REPORT_STATUS_INFO_S *pReport = (MSG_REPORT_STATUS_INFO_S *)report_info;
1576         switch(field)
1577         {
1578         case MSG_REPORT_TYPE_INT:
1579                 result = pReport->type;
1580                 break;
1581         case MSG_REPORT_STATUS_INT:
1582                 result = pReport->status;
1583                 break;
1584         case MSG_REPORT_TIME_INT:
1585                 result = pReport->statusTime;
1586                 break;
1587
1588         default:
1589                 result = MSG_ERR_INVALID_PARAMETER;
1590                 break;
1591         }
1592         return result;
1593 }
1594
1595 char* msg_report_status_get_str(void *report_info, int field)
1596 {
1597         char *result = NULL;
1598         MSG_REPORT_STATUS_INFO_S *pReport = (MSG_REPORT_STATUS_INFO_S *)report_info;
1599         switch(field)
1600         {
1601
1602         case MSG_REPORT_ADDRESS_STR:
1603                 result = pReport->addressVal;
1604                 break;
1605
1606         default:
1607                 break;
1608         }
1609         return result;
1610 }
1611
1612 char* msg_folder_info_get_str(void *folder_info, int field)
1613 {
1614         char *result = NULL;
1615         MSG_FOLDER_INFO_S *pFolder = (MSG_FOLDER_INFO_S *)folder_info;
1616         switch(field)
1617         {
1618         case MSG_FOLDER_INFO_NAME_STR:
1619                 result = pFolder->folderName;
1620                 break;
1621         default:
1622                 result = NULL;
1623                 break;
1624         }
1625         return result;
1626 }
1627
1628 char *msg_thread_info_get_str(void *data, int field)
1629 {
1630         char *ret_str = NULL;
1631         MSG_THREAD_VIEW_S *pThread = (MSG_THREAD_VIEW_S *)data;
1632
1633         switch(field)
1634         {
1635         case MSG_THREAD_NAME_STR :
1636                 ret_str = pThread->threadName;
1637                 break;
1638         case MSG_THREAD_MSG_DATA_STR :
1639                 ret_str = pThread->threadData;
1640                 break;
1641         default:
1642                 break;
1643         }
1644
1645         return ret_str;
1646 }
1647
1648
1649 char *msg_conv_info_get_str(void *data, int field)
1650 {
1651         char *ret_str = NULL;
1652         MSG_CONVERSATION_VIEW_S *pConv = (MSG_CONVERSATION_VIEW_S *)data;
1653
1654         switch(field)
1655         {
1656         case MSG_CONV_MSG_SUBJECT_STR :
1657                 ret_str = pConv->subject;
1658                 break;
1659         case MSG_CONV_MSG_ATTACH_NAME_STR :
1660                 ret_str = pConv->attachFileName;
1661                 break;
1662         case MSG_CONV_MSG_AUDIO_NAME_STR :
1663                 ret_str = pConv->audioFileName;
1664                 break;
1665         case MSG_CONV_MSG_IMAGE_THUMB_PATH_STR :
1666                 ret_str = pConv->imageThumbPath;
1667                 break;
1668         case MSG_CONV_MSG_VIDEO_THUMB_PATH_STR :
1669                 ret_str = pConv->videoThumbPath;
1670                 break;
1671         case MSG_CONV_MSG_TEXT_STR :
1672                 ret_str = pConv->pText;
1673                 break;
1674         default:
1675                 break;
1676         }
1677
1678         return ret_str;
1679 }
1680
1681
1682 char* msg_search_condition_get_str(void *condition_info, int field, int size)
1683 {
1684         char *result = NULL;
1685         MSG_SEARCH_CONDITION_S *search_cond = (MSG_SEARCH_CONDITION_S *)condition_info;
1686         switch(field)
1687         {
1688         case MSG_SEARCH_CONDITION_ADDRESS_VALUE_STR:
1689                 result = search_cond->pAddressVal;
1690                 break;
1691         case MSG_SEARCH_CONDITION_SEARCH_VALUE_STR:
1692                 result = search_cond->pSearchVal;
1693                 break;
1694
1695         default:
1696                 result = NULL;
1697                 break;
1698         }
1699         return result;
1700 }
1701
1702 bool msg_sendopt_get_bool(void *send_opt, int field)
1703 {
1704         bool result = false;
1705         MSG_SENDINGOPT_S *sendopt = (MSG_SENDINGOPT_S *)send_opt;
1706         switch(field)
1707         {
1708         case MSG_SEND_OPT_SETTING_BOOL:
1709                 result = sendopt->bDeliverReq;
1710                 break;
1711         case MSG_SEND_OPT_KEEPCOPY_BOOL:
1712                 result = sendopt->bDeliverReq;
1713                 break;
1714         case MSG_SEND_OPT_DELIVER_REQ_BOOL:
1715                 result = sendopt->bDeliverReq;
1716                 break;
1717         default:
1718                 break;
1719         }
1720         return result;
1721 }
1722
1723 bool msg_sortrule_get_bool(void *sort_rule, int field)
1724 {
1725         bool result = false;
1726         MSG_SORT_RULE_S *pSort = (MSG_SORT_RULE_S *)sort_rule;
1727         switch(field)
1728         {
1729         case MSG_SORT_RULE_ACSCEND_BOOL:
1730                 result = pSort->bAscending;
1731                 break;
1732         default:
1733                 break;
1734         }
1735         return result;
1736 }
1737
1738 bool msg_conv_get_bool(void *data, int field)
1739 {
1740         bool result = false;
1741         MSG_CONVERSATION_VIEW_S *pConv = (MSG_CONVERSATION_VIEW_S *)data;
1742         switch(field)
1743         {
1744         case MSG_CONV_MSG_READ_BOOL:
1745                 result = pConv->bRead;
1746                 break;
1747         case MSG_CONV_MSG_PROTECTED_BOOL:
1748                 result = pConv->bProtected;
1749                 break;
1750         default:
1751                 break;
1752         }
1753         return result;
1754 }
1755
1756 bool msg_thread_info_get_bool(void *data, int field)
1757 {
1758         bool result = false;
1759         MSG_THREAD_VIEW_S *pthreadInfo = (MSG_THREAD_VIEW_S *)data;
1760         switch(field)
1761         {
1762         case MSG_THREAD_PROTECTED_BOOL:
1763                 result = pthreadInfo->bProtected;
1764                 break;
1765         default:
1766                 break;
1767         }
1768         return result;
1769 }
1770
1771 int msg_sendopt_get_struct_handle(msg_struct_s *msg_struct, int field, void **value)
1772 {
1773         msg_error_t err =  MSG_SUCCESS;
1774         if(!msg_struct || !value)
1775                 return MSG_ERR_NULL_POINTER;
1776
1777         MSG_SENDINGOPT_S *sendopt = (MSG_SENDINGOPT_S *)msg_struct->data;
1778
1779         switch(field)
1780         {
1781         case MSG_SEND_OPT_MMS_OPT_HND:
1782                 *value = (void *)sendopt->mmsSendOpt;
1783                 break;
1784         case MSG_SEND_OPT_SMS_OPT_HND:
1785                 *value = (void *)sendopt->smsSendOpt;
1786                 break;
1787         default:
1788                 err = MSG_ERR_UNKNOWN;
1789                 break;
1790         }
1791         return err;
1792 }
1793
1794 int msg_syncml_get_struct_handle(msg_struct_s *msg_struct, int field, void **value)
1795 {
1796         msg_error_t err =  MSG_SUCCESS;
1797
1798         if(!msg_struct || !value)
1799                 return MSG_ERR_NULL_POINTER;
1800
1801         MSG_SYNCML_MESSAGE_S *pSync = (MSG_SYNCML_MESSAGE_S *)msg_struct->data;
1802         switch(field)
1803         {
1804         case MSG_SYNCML_INFO_MESSAGE_HND:
1805                 *value = (void *)pSync->msg;
1806                 break;
1807         default:
1808                 err = MSG_ERR_UNKNOWN;
1809                 break;
1810
1811         }
1812         return err;
1813 }
1814
1815 int msg_thread_index_get_struct_handle(msg_struct_s *msg_struct, int field, void **value)
1816 {
1817         msg_error_t err =  MSG_SUCCESS;
1818
1819         if(!msg_struct || !value)
1820                 return MSG_ERR_NULL_POINTER;
1821
1822         MSG_THREAD_LIST_INDEX_INFO_S *pIndex = (MSG_THREAD_LIST_INDEX_INFO_S *)msg_struct->data;
1823         switch(field)
1824         {
1825         case MSG_SYNCML_INFO_MESSAGE_HND:
1826                 *value = (void *)pIndex->msgAddrInfo;
1827                 break;
1828         default:
1829                 err = MSG_ERR_UNKNOWN;
1830                 break;
1831
1832         }
1833         return err;
1834 }
1835
1836 int msg_address_info_get_int(void *addr_info, int field)
1837 {
1838         int result = MSG_ERR_INVALID_PARAMETER;
1839         MSG_ADDRESS_INFO_S *pAddr = (MSG_ADDRESS_INFO_S *)addr_info;
1840         switch(field)
1841         {
1842         case MSG_ADDRESS_INFO_ADDRESS_TYPE_INT:
1843                 result = pAddr->addressType;
1844                 break;
1845         case MSG_ADDRESS_INFO_RECIPIENT_TYPE_INT:
1846                 result = pAddr->recipientType;
1847                 break;
1848         case MSG_ADDRESS_INFO_CONTACT_ID_INT:
1849                 result = pAddr->contactId;
1850                 break;
1851         default:
1852                 break;
1853         }
1854         return result;
1855 }
1856 int msg_mms_sendopt_get_int(void *opt_info, int field)
1857 {
1858         int result = MSG_ERR_INVALID_PARAMETER;
1859         MMS_SENDINGOPT_S *pOpt = (MMS_SENDINGOPT_S *)opt_info;
1860         switch(field)
1861         {
1862         case MSG_MMS_SENDOPTION_EXPIRY_TIME_INT:
1863                 result = pOpt->expiryTime;
1864                 break;
1865         case MSG_MMS_SENDOPTION_DELIVERY_TIME_INT:
1866                 result = pOpt->deliveryTime;
1867                 break;
1868         case MSG_MMS_SENDOPTION_PRIORITY_INT:
1869                 result = pOpt->priority;
1870                 break;
1871         default:
1872                 break;
1873         }
1874         return result;
1875 }
1876
1877 int msg_reject_message_get_int(void *msg_info, int field)
1878 {
1879         int result = MSG_ERR_INVALID_PARAMETER;
1880         MSG_REJECT_MSG_INFO_S *pMsg = (MSG_REJECT_MSG_INFO_S *)msg_info;
1881         switch(field)
1882         {
1883         case MSG_REJECT_MESSAGE_MSGID_INT:
1884                 result = pMsg->msgId;
1885                 break;
1886         case MSG_REJECT_MESSAGE_DISPLAY_TIME_INT:
1887                 result = pMsg->displayTime;
1888                 break;
1889         default:
1890                 break;
1891         }
1892         return result;
1893 }
1894
1895 char* msg_address_info_get_str(void *addr_info, int field, int size)
1896 {
1897         char *result = NULL;
1898         MSG_ADDRESS_INFO_S *pAddr = (MSG_ADDRESS_INFO_S *)addr_info;
1899         switch(field)
1900         {
1901         case MSG_ADDRESS_INFO_ADDRESS_VALUE_STR:
1902                 result = pAddr->addressVal;
1903                 break;
1904         case MSG_ADDRESS_INFO_DISPLAYNAME_STR:
1905                 result = pAddr->displayName;
1906                 break;
1907
1908         default:
1909                 result = NULL;
1910                 break;
1911         }
1912         return result;
1913 }
1914
1915 char* msg_reject_message_get_str(void *msg_info, int field, int size)
1916 {
1917         char *result = NULL;
1918         MSG_REJECT_MSG_INFO_S *pMsg = (MSG_REJECT_MSG_INFO_S *)msg_info;
1919         switch(field)
1920         {
1921         case MSG_REJECT_MESSAGE_MSGTEXT_STR:
1922                 result = pMsg->msgText;
1923                 break;
1924         default:
1925                 result = NULL;
1926                 break;
1927         }
1928         return result;
1929 }
1930
1931 bool msg_mms_sendopt_get_bool(void *opt_info, int field)
1932 {
1933         bool result = false;
1934         MMS_SENDINGOPT_S *pOpt = (MMS_SENDINGOPT_S *)opt_info;
1935         switch(field)
1936         {
1937         case MSG_MMS_SENDOPTION_READ_REQUEST_BOOL:
1938                 result = pOpt->bReadReq;
1939                 break;
1940         case MSG_MMS_SENDOPTION_DELIVERY_CUSTOMTIME_BOOL:
1941                 result = pOpt->bUseDeliveryCustomTime;
1942                 break;
1943         default:
1944                 break;
1945         }
1946         return result;
1947 }
1948
1949 bool msg_sms_sendopt_get_bool(void *opt_info, int field)
1950 {
1951         bool result = false;
1952         SMS_SENDINGOPT_S *pOpt = (SMS_SENDINGOPT_S *)opt_info;
1953         switch(field)
1954         {
1955         case MSG_SMS_SENDOPT_REPLYPATH_BOOL:
1956                 result = pOpt->bReplyPath;
1957                 break;
1958         default:
1959                 break;
1960         }
1961         return result;
1962 }
1963
1964 int msg_syncml_info_set_int(void *syncml_info, int field, int value)
1965 {
1966
1967         msg_error_t err =  MSG_SUCCESS;
1968         if(!syncml_info)
1969                 return MSG_ERR_NULL_POINTER;
1970
1971     MSG_SYNCML_MESSAGE_S *pSync = (MSG_SYNCML_MESSAGE_S *)syncml_info;
1972     switch(field)
1973     {
1974     case MSG_SYNCML_INFO_EXTID_INT:
1975                 pSync->extId = value;
1976                 break;
1977     case MSG_SYNCML_INFO_PINCODE_INT:
1978                 pSync->pinCode = value;
1979                 break;
1980     default:
1981                 err = MSG_ERR_UNKNOWN;
1982                 break;
1983     }
1984
1985         return err;
1986 }
1987
1988 int msg_count_info_set_int(void *count_info, int field, int value)
1989 {
1990         msg_error_t err =  MSG_SUCCESS;
1991         if(!count_info)
1992                 return MSG_ERR_NULL_POINTER;
1993
1994     MSG_COUNT_INFO_S *pCount = (MSG_COUNT_INFO_S *)count_info;
1995
1996     switch(field)
1997     {
1998     case MSG_COUNT_INFO_READ_INT:
1999                 pCount->nReadCnt = value;
2000                 break;
2001     case MSG_COUNT_INFO_UNREAD_INT:
2002                 pCount->nUnreadCnt = value;
2003                 break;
2004     case MSG_COUNT_INFO_SMS_INT:
2005                 pCount->nSms = value;
2006                 break;
2007     case MSG_COUNT_INFO_MMS_INT:
2008                 pCount->nMms = value;
2009                 break;
2010     default:
2011                 err = MSG_ERR_UNKNOWN;
2012                 break;
2013     }
2014         return err;
2015 }
2016
2017 int msg_thread_count_set_int(void *count_info, int field, int value)
2018 {
2019         msg_error_t err =  MSG_SUCCESS;
2020         if(!count_info)
2021                 return MSG_ERR_NULL_POINTER;
2022
2023     MSG_THREAD_COUNT_INFO_S *pCount = (MSG_THREAD_COUNT_INFO_S *)count_info;
2024     switch(field)
2025     {
2026     case MSG_THREAD_COUNT_TOTAL_INT:
2027                 pCount->totalCount = value;
2028                 break;
2029     case MSG_THREAD_COUNT_UNREAD_INT:
2030                 pCount->unReadCount = value;
2031                 break;
2032     case MSG_THREAD_COUNT_SMS_INT:
2033                 pCount->smsMsgCount = value;
2034                 break;
2035     case MSG_THREAD_COUNT_MMS_INT:
2036                 pCount->mmsMsgCount = value;
2037                 break;
2038     default:
2039                 err = MSG_ERR_UNKNOWN;
2040                 break;
2041     }
2042         return err;
2043 }
2044
2045 int msg_thread_index_set_int(void *index_info, int field, int value)
2046 {
2047         msg_error_t err =  MSG_SUCCESS;
2048         if(!index_info)
2049                 return MSG_ERR_NULL_POINTER;
2050
2051     MSG_THREAD_LIST_INDEX_S *pIndex = (MSG_THREAD_LIST_INDEX_S *)index_info;
2052     switch(field)
2053     {
2054     case MSG_THREAD_LIST_INDEX_CONTACTID_INT:
2055                 pIndex->contactId = value;
2056                 break;
2057     default:
2058                 err = MSG_ERR_UNKNOWN;
2059                 break;
2060     }
2061
2062         return err;
2063 }
2064
2065 int msg_sortrule_set_int(void *sort_info, int field, int value)
2066 {
2067         msg_error_t err =  MSG_SUCCESS;
2068
2069         if(!sort_info)
2070                 return MSG_ERR_NULL_POINTER;
2071
2072     MSG_SORT_RULE_S *pSort = (MSG_SORT_RULE_S *)sort_info;
2073     switch(field)
2074     {
2075     case MSG_SORT_RULE_SORT_TYPE_INT:
2076                 pSort->sortType = value;
2077                 break;
2078     default:
2079                 err = MSG_ERR_UNKNOWN;
2080                 break;
2081     }
2082         return err;
2083 }
2084
2085 int msg_folder_info_set_int(void *folder_info, int field, int value)
2086 {
2087         msg_error_t err =  MSG_SUCCESS;
2088         if(!folder_info)
2089                 return MSG_ERR_NULL_POINTER;
2090
2091     MSG_FOLDER_INFO_S *pFolder = (MSG_FOLDER_INFO_S *)folder_info;
2092     switch(field)
2093     {
2094     case MSG_FOLDER_INFO_ID_INT:
2095                 pFolder->folderId = value;
2096                 break;
2097     case MSG_FOLDER_INFO_TYPE_INT:
2098                 pFolder->folderType = value;
2099                 break;
2100     default:
2101                 err = MSG_ERR_UNKNOWN;
2102                 break;
2103     }
2104
2105         return err;
2106 }
2107
2108 int msg_search_condition_set_int(void *condition_info, int field, int value)
2109 {
2110         msg_error_t err =  MSG_SUCCESS;
2111         if(!condition_info)
2112                 return MSG_ERR_NULL_POINTER;
2113
2114     MSG_SEARCH_CONDITION_S *pCond = (MSG_SEARCH_CONDITION_S *)condition_info;
2115     switch(field)
2116     {
2117     case MSG_SEARCH_CONDITION_FOLDERID_INT:
2118                 pCond->folderId = value;
2119                 break;
2120     case MSG_SEARCH_CONDITION_MSGTYPE_INT:
2121                 pCond->msgType = value;
2122                 break;
2123     case MSG_SEARCH_CONDITION_RESERVED_INT:
2124                 pCond->reserved = value;
2125                 break;
2126     default:
2127                 err = MSG_ERR_UNKNOWN;
2128                 break;
2129     }
2130
2131         return err;
2132 }
2133
2134 int msg_report_status_set_int(void *report_info, int field, int value)
2135 {
2136         msg_error_t err =  MSG_SUCCESS;
2137         if(!report_info)
2138         return MSG_ERR_NULL_POINTER;
2139
2140         MSG_REPORT_STATUS_INFO_S *pReport = (MSG_REPORT_STATUS_INFO_S *)report_info;
2141         switch(field)
2142         {
2143                 case MSG_REPORT_TYPE_INT:
2144                         pReport->type = value;
2145                 break;
2146                 case MSG_REPORT_STATUS_INT:
2147                         pReport->status = value;
2148                 break;
2149                 case MSG_REPORT_TIME_INT:
2150                         pReport->statusTime = value;
2151                 break;
2152
2153                 default:
2154                 err = MSG_ERR_UNKNOWN;
2155                 break;
2156         }
2157
2158         return err;
2159 }
2160
2161 int msg_folder_info_set_str(void *folder_info, int field, char *value, int size)
2162 {
2163         msg_error_t err =  MSG_SUCCESS;
2164         if(!folder_info || !value)
2165                 return MSG_ERR_NULL_POINTER;
2166     MSG_FOLDER_INFO_S *pFolder = (MSG_FOLDER_INFO_S *)folder_info;
2167     int _len = 0;
2168     (size > MAX_FOLDER_NAME_SIZE)? _len = MAX_FOLDER_NAME_SIZE : _len = size;
2169     switch(field)
2170     {
2171     case MSG_FOLDER_INFO_NAME_STR:
2172                 strncpy(pFolder->folderName, value, _len);
2173                 break;
2174     default:
2175                 err = MSG_ERR_UNKNOWN;
2176                 break;
2177     }
2178
2179         return err;
2180 }
2181
2182 int msg_search_condition_set_str(void *condition_info, int field, char *value, int size)
2183 {
2184         msg_error_t err =  MSG_SUCCESS;
2185         if(!condition_info || !value)
2186                 return MSG_ERR_NULL_POINTER;
2187
2188     MSG_SEARCH_CONDITION_S *search_cond = (MSG_SEARCH_CONDITION_S *)condition_info;
2189
2190     switch(field)
2191     {
2192     case MSG_SEARCH_CONDITION_ADDRESS_VALUE_STR:
2193                 search_cond->pAddressVal = value;
2194                 break;
2195     case MSG_SEARCH_CONDITION_SEARCH_VALUE_STR:
2196                 search_cond->pSearchVal = value;
2197                 break;
2198
2199     default:
2200                 err = MSG_ERR_UNKNOWN;
2201                 break;
2202     }
2203         return err;
2204 }
2205
2206 int msg_sendopt_set_bool(void *send_opt, int field, bool value)
2207 {
2208         msg_error_t err =  MSG_SUCCESS;
2209         if(!send_opt)
2210                 return MSG_ERR_NULL_POINTER;
2211
2212     MSG_SENDINGOPT_S *sendopt = (MSG_SENDINGOPT_S *)send_opt;
2213     switch(field)
2214     {
2215     case MSG_SEND_OPT_SETTING_BOOL:
2216                 sendopt->bDeliverReq = value;
2217                 break;
2218     case MSG_SEND_OPT_KEEPCOPY_BOOL:
2219                 sendopt->bDeliverReq = value;
2220                 break;
2221     case MSG_SEND_OPT_DELIVER_REQ_BOOL:
2222                 sendopt->bDeliverReq = value;
2223                 break;
2224     default:
2225                 err = MSG_ERR_UNKNOWN;
2226                 break;
2227     }
2228         return err;
2229 }
2230
2231 int msg_sortrule_set_bool(void *sort_rule, int field, bool value)
2232 {
2233         msg_error_t err =  MSG_SUCCESS;
2234         if(!sort_rule)
2235                 return MSG_ERR_NULL_POINTER;
2236
2237     MSG_SORT_RULE_S *pSort = (MSG_SORT_RULE_S *)sort_rule;
2238     switch(field)
2239     {
2240     case MSG_SORT_RULE_ACSCEND_BOOL:
2241                 pSort->bAscending = value;
2242                 break;
2243     default:
2244                 err = MSG_ERR_UNKNOWN;
2245                 break;
2246     }
2247         return err;
2248 }
2249
2250 int msg_sendopt_set_struct_handle(msg_struct_s *msg_struct, int field, msg_struct_s *value)
2251 {
2252         msg_error_t err =  MSG_SUCCESS;
2253         if(!msg_struct || !value)
2254                 return MSG_ERR_NULL_POINTER;
2255
2256         MSG_SENDINGOPT_S *sendopt = (MSG_SENDINGOPT_S *)msg_struct->data;
2257         msg_struct_s *pTmp = NULL;
2258
2259         switch(field)
2260         {
2261         case MSG_SEND_OPT_MMS_OPT_HND:
2262                 pTmp = (msg_struct_s *)sendopt->mmsSendOpt;
2263                 memcpy(pTmp->data, value->data, sizeof(MMS_SENDINGOPT_INFO_S));
2264                 break;
2265         case MSG_SEND_OPT_SMS_OPT_HND:
2266                 pTmp = (msg_struct_s *)sendopt->smsSendOpt;
2267                 memcpy(pTmp->data, value->data, sizeof(SMS_SENDINGOPT_INFO_S));
2268                 break;
2269         default:
2270                 err = MSG_ERR_UNKNOWN;
2271                 break;
2272         }
2273         return err;
2274 }
2275
2276 int msg_syncml_set_struct_handle(msg_struct_s *msg_struct, int field, msg_struct_s *value)
2277 {
2278         msg_error_t err =  MSG_SUCCESS;
2279
2280         if(!msg_struct || !value)
2281                 return MSG_ERR_NULL_POINTER;
2282
2283         MSG_SYNCML_MESSAGE_S *pSync = (MSG_SYNCML_MESSAGE_S *)msg_struct->data;
2284         msg_struct_s *pTmp = NULL;
2285
2286         switch(field)
2287         {
2288         case MSG_SYNCML_INFO_MESSAGE_HND:
2289         {
2290                 pTmp = (msg_struct_s *)pSync->msg;
2291                 MSG_MESSAGE_HIDDEN_S *pSrc = (MSG_MESSAGE_HIDDEN_S *)value->data;
2292                 MSG_MESSAGE_HIDDEN_S *pDst = (MSG_MESSAGE_HIDDEN_S *)pTmp->data;
2293                 msg_message_copy_message(pSrc, pDst);
2294                 break;
2295         }
2296         default:
2297                 err = MSG_ERR_UNKNOWN;
2298                 break;
2299
2300         }
2301         return err;
2302 }
2303
2304 int msg_thread_index_set_struct_handle(msg_struct_s *msg_struct, int field, msg_struct_s *value)
2305 {
2306         msg_error_t err =  MSG_SUCCESS;
2307
2308         if(!msg_struct || !value)
2309                 return MSG_ERR_NULL_POINTER;
2310
2311         MSG_THREAD_LIST_INDEX_INFO_S *pIndex = (MSG_THREAD_LIST_INDEX_INFO_S *)msg_struct->data;
2312         msg_struct_s *pTmp = NULL;
2313
2314         switch(field)
2315         {
2316         case MSG_THREAD_LIST_INDEX_ADDR_INFO_HND:
2317                 pTmp = (msg_struct_s *)pIndex->msgAddrInfo;
2318                 memcpy(pTmp->data, value->data, sizeof(MSG_ADDRESS_INFO_S));
2319                 break;
2320         default:
2321                 err = MSG_ERR_UNKNOWN;
2322                 break;
2323
2324         }
2325         return err;
2326 }
2327
2328 int msg_address_info_set_int(void *addrinfo, int field, int value)
2329 {
2330         msg_error_t err =  MSG_SUCCESS;
2331         if(!addrinfo)
2332                 return MSG_ERR_NULL_POINTER;
2333
2334         MSG_ADDRESS_INFO_S *pAddr = (MSG_ADDRESS_INFO_S *)addrinfo;
2335         switch(field)
2336         {
2337         case MSG_ADDRESS_INFO_ADDRESS_TYPE_INT:
2338                 pAddr->addressType = value;
2339                 break;
2340         case MSG_ADDRESS_INFO_RECIPIENT_TYPE_INT:
2341                 pAddr->recipientType = value;
2342                 break;
2343         case MSG_ADDRESS_INFO_CONTACT_ID_INT:
2344                 pAddr->contactId = value;
2345                 break;
2346         default:
2347                 err = MSG_ERR_UNKNOWN;
2348         break;
2349         }
2350
2351         return err;
2352 }
2353
2354
2355 int msg_mms_sendopt_set_int(void *opt_info, int field, int value)
2356 {
2357         msg_error_t err =  MSG_SUCCESS;
2358         if(!opt_info)
2359                 return MSG_ERR_NULL_POINTER;
2360
2361         MMS_SENDINGOPT_S *pOpt = (MMS_SENDINGOPT_S *)opt_info;
2362         switch(field)
2363         {
2364         case MSG_MMS_SENDOPTION_EXPIRY_TIME_INT:
2365                 pOpt->expiryTime = value;
2366                 break;
2367         case MSG_MMS_SENDOPTION_DELIVERY_TIME_INT:
2368                 pOpt->deliveryTime = value;
2369                 break;
2370         case MSG_MMS_SENDOPTION_PRIORITY_INT:
2371                 pOpt->priority = value;
2372                 break;
2373         default:
2374                 err = MSG_ERR_UNKNOWN;
2375         break;
2376         }
2377
2378         return err;
2379 }
2380
2381 int msg_reject_message_set_int(void *msg_info, int field, int value)
2382 {
2383         msg_error_t err =  MSG_SUCCESS;
2384         if(!msg_info)
2385                 return MSG_ERR_NULL_POINTER;
2386
2387         MSG_REJECT_MSG_INFO_S *pMsg = (MSG_REJECT_MSG_INFO_S *)msg_info;
2388         switch(field)
2389         {
2390         case MSG_REJECT_MESSAGE_MSGID_INT:
2391                 pMsg->msgId = value;
2392                 break;
2393         case MSG_REJECT_MESSAGE_DISPLAY_TIME_INT:
2394                 pMsg->displayTime = value;
2395                 break;
2396         default:
2397                 err = MSG_ERR_UNKNOWN;
2398         break;
2399         }
2400
2401         return err;
2402 }
2403
2404 int msg_address_info_set_str(void *addr_info, int field, char *value, int size)
2405 {
2406         msg_error_t err =  MSG_SUCCESS;
2407         if(!addr_info || !value)
2408                 return MSG_ERR_NULL_POINTER;
2409     MSG_ADDRESS_INFO_S *pAddr = (MSG_ADDRESS_INFO_S *)addr_info;
2410     int _len = 0;
2411
2412     switch(field)
2413     {
2414     case MSG_ADDRESS_INFO_ADDRESS_VALUE_STR:
2415         (size > MAX_ADDRESS_VAL_LEN)? _len = MAX_ADDRESS_VAL_LEN : _len = size;
2416         memset(pAddr->addressVal, 0x00, sizeof(pAddr->addressVal));
2417                 strncpy(pAddr->addressVal, value, _len);
2418                 break;
2419     case MSG_ADDRESS_INFO_DISPLAYNAME_STR:
2420         (size > MAX_DISPLAY_NAME_LEN)? _len = MAX_DISPLAY_NAME_LEN : _len = size;
2421         memset(pAddr->displayName, 0x00, sizeof(pAddr->displayName));
2422                 strncpy(pAddr->displayName, value, _len);
2423                 break;
2424     default:
2425                 err = MSG_ERR_UNKNOWN;
2426                 break;
2427     }
2428
2429         return err;
2430 }
2431 int msg_reject_message_set_str(void *msg_info, int field, char *value, int size)
2432 {
2433         msg_error_t err =  MSG_SUCCESS;
2434         if(!msg_info || !value)
2435                 return MSG_ERR_NULL_POINTER;
2436     MSG_REJECT_MSG_INFO_S *pMsg = (MSG_REJECT_MSG_INFO_S *)msg_info;
2437     int _len = 0;
2438     (size > MAX_MSG_TEXT_LEN)? _len = MAX_MSG_TEXT_LEN : _len = size;
2439     switch(field)
2440     {
2441     case MSG_REJECT_MESSAGE_MSGTEXT_STR:
2442                 strncpy(pMsg->msgText, value, _len);
2443                 break;
2444     default:
2445                 err = MSG_ERR_UNKNOWN;
2446                 break;
2447     }
2448
2449         return err;
2450 }
2451
2452 int msg_mms_sendopt_set_bool(void *option, int field, bool value)
2453 {
2454         msg_error_t err =  MSG_SUCCESS;
2455         if(!option)
2456                 return MSG_ERR_NULL_POINTER;
2457
2458     MMS_SENDINGOPT_S *pOpt = (MMS_SENDINGOPT_S *)option;
2459     switch(field)
2460     {
2461     case MSG_MMS_SENDOPTION_READ_REQUEST_BOOL:
2462                 pOpt->bReadReq = value;
2463                 break;
2464     case MSG_MMS_SENDOPTION_DELIVERY_CUSTOMTIME_BOOL:
2465                 pOpt->bUseDeliveryCustomTime = value;
2466                 break;
2467     default:
2468                 err = MSG_ERR_UNKNOWN;
2469                 break;
2470     }
2471         return err;
2472 }
2473
2474 int msg_sms_sendopt_set_bool(void *option, int field, bool value)
2475 {
2476         msg_error_t err =  MSG_SUCCESS;
2477         if(!option)
2478                 return MSG_ERR_NULL_POINTER;
2479
2480     SMS_SENDINGOPT_S *pOpt = (SMS_SENDINGOPT_S *)option;
2481     switch(field)
2482     {
2483     case MSG_SMS_SENDOPT_REPLYPATH_BOOL:
2484                 pOpt->bReplyPath = value;
2485                 break;
2486     default:
2487         err = MSG_ERR_UNKNOWN;
2488                 break;
2489     }
2490         return err;
2491 }
2492
2493 EXPORT_API int msg_add_push_event(msg_handle_t handle, const msg_struct_t push_event)
2494 {
2495         msg_error_t err =  MSG_SUCCESS;
2496
2497         if (handle == NULL || push_event == NULL)
2498         {
2499                 return -EINVAL;
2500         }
2501
2502         MsgHandle* pHandle = (MsgHandle*)handle;
2503
2504         msg_struct_s *pPush = (msg_struct_s *)push_event;
2505
2506         try
2507         {
2508                 err = pHandle->addPushEvent((MSG_PUSH_EVENT_INFO_S *)pPush->data);
2509         }
2510         catch (MsgException& e)
2511         {
2512                 MSG_FATAL("%s", e.what());
2513                 return MSG_ERR_STORAGE_ERROR;
2514         }
2515
2516         return err;
2517 }
2518
2519 EXPORT_API int msg_delete_push_event(msg_handle_t handle, const msg_struct_t push_event)
2520 {
2521         msg_error_t err =  MSG_SUCCESS;
2522
2523         if (handle == NULL || push_event == NULL)
2524         {
2525                 return -EINVAL;
2526         }
2527
2528         MsgHandle* pHandle = (MsgHandle*)handle;
2529
2530         msg_struct_s *pPush = (msg_struct_s *)push_event;
2531
2532         try
2533         {
2534                 err = pHandle->deletePushEvent((MSG_PUSH_EVENT_INFO_S *)pPush->data);
2535         }
2536         catch (MsgException& e)
2537         {
2538                 MSG_FATAL("%s", e.what());
2539                 return MSG_ERR_STORAGE_ERROR;
2540         }
2541
2542         return err;
2543 }
2544
2545 EXPORT_API int msg_update_push_event(msg_handle_t handle, const msg_struct_t src_event, const msg_struct_t dst_event)
2546 {
2547         msg_error_t err =  MSG_SUCCESS;
2548
2549         if (handle == NULL || src_event == NULL || dst_event == NULL)
2550         {
2551                 return -EINVAL;
2552         }
2553
2554         MsgHandle* pHandle = (MsgHandle*)handle;
2555
2556         msg_struct_s *pSrc = (msg_struct_s *)src_event;
2557         msg_struct_s *pDst = (msg_struct_s *)dst_event;
2558
2559         try
2560         {
2561                 err = pHandle->updatePushEvent((MSG_PUSH_EVENT_INFO_S *)pSrc->data, (MSG_PUSH_EVENT_INFO_S *)pDst->data);
2562         }
2563         catch (MsgException& e)
2564         {
2565                 MSG_FATAL("%s", e.what());
2566                 return MSG_ERR_STORAGE_ERROR;
2567         }
2568
2569         return err;
2570 }
2571
2572 char* msg_push_config_get_str(void *event_info, int field, int size)
2573 {
2574         char *result = NULL;
2575         MSG_PUSH_EVENT_INFO_S *pEvent = (MSG_PUSH_EVENT_INFO_S *)event_info;
2576         switch(field)
2577         {
2578     case MSG_PUSH_CONFIG_CONTENT_TYPE_STR:
2579                 result = pEvent->contentType;
2580                 break;
2581     case MSG_PUSH_CONFIG_APPLICATON_ID_STR:
2582                 result = pEvent->appId;
2583                 break;
2584     case MSG_PUSH_CONFIG_PACKAGE_NAME_STR:
2585                 result = pEvent->pkgName;
2586                 break;
2587
2588         default:
2589                 result = NULL;
2590                 break;
2591         }
2592         return result;
2593 }
2594
2595 bool msg_push_config_get_bool(void *event_info, int field)
2596 {
2597         bool result = false;
2598         MSG_PUSH_EVENT_INFO_S *pEvent = (MSG_PUSH_EVENT_INFO_S *)event_info;
2599         switch(field)
2600         {
2601     case MSG_PUSH_CONFIG_LAUNCH_BOOL:
2602         result = pEvent->bLaunch;
2603                 break;
2604         default:
2605                 break;
2606         }
2607         return result;
2608 }
2609
2610 int msg_push_config_set_str(void *event_info, int field, char *value, int size)
2611 {
2612         msg_error_t err =  MSG_SUCCESS;
2613         if(!event_info || !value)
2614                 return MSG_ERR_NULL_POINTER;
2615     MSG_PUSH_EVENT_INFO_S *pEvent = (MSG_PUSH_EVENT_INFO_S *)event_info;
2616     int _len = 0;
2617
2618     switch(field)
2619     {
2620     case MSG_PUSH_CONFIG_CONTENT_TYPE_STR:
2621         (size > MAX_WAPPUSH_CONTENT_TYPE_LEN)? _len = MAX_WAPPUSH_CONTENT_TYPE_LEN : _len = size;
2622                 strncpy(pEvent->contentType, value, _len);
2623                 break;
2624     case MSG_PUSH_CONFIG_APPLICATON_ID_STR:
2625         (size > MAX_WAPPUSH_ID_LEN)? _len = MAX_WAPPUSH_ID_LEN : _len = size;
2626                 strncpy(pEvent->appId, value, _len);
2627                 break;
2628     case MSG_PUSH_CONFIG_PACKAGE_NAME_STR:
2629         (size > MSG_FILEPATH_LEN_MAX)? _len = MSG_FILEPATH_LEN_MAX : _len = size;
2630                 strncpy(pEvent->pkgName, value, _len);
2631                 break;
2632     default:
2633         err = MSG_ERR_UNKNOWN;
2634                 break;
2635     }
2636
2637         return err;
2638 }
2639
2640 int msg_push_config_set_bool(void *event, int field, bool value)
2641 {
2642         msg_error_t err =  MSG_SUCCESS;
2643         if(!event)
2644                 return MSG_ERR_NULL_POINTER;
2645
2646         MSG_PUSH_EVENT_INFO_S *pEvent = (MSG_PUSH_EVENT_INFO_S *)event;
2647     switch(field)
2648     {
2649     case MSG_PUSH_CONFIG_LAUNCH_BOOL:
2650         pEvent->bLaunch = value;
2651                 break;
2652     default:
2653         err = MSG_ERR_UNKNOWN;
2654                 break;
2655     }
2656         return err;
2657 }