mapi/msg_storage.cpp

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