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