2 * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
19 #include "MsgHandle.h"
21 #include "MsgException.h"
24 #include "msg_private.h"
25 #include "msg_storage.h"
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)
34 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
37 if (handle == NULL || opq_msg == NULL || send_opt == NULL)
38 return MSG_ERR_INVALID_PARAMETER;
40 MsgHandle* pHandle = (MsgHandle*)handle;
42 msg_struct_s *pMsgStruct = (msg_struct_s *)opq_msg;
43 MSG_TYPE_CHECK(pMsgStruct->type, MSG_STRUCT_MESSAGE_INFO);
45 msg_struct_s *pStruct = (msg_struct_s *)send_opt;
46 MSG_TYPE_CHECK(pStruct->type, MSG_STRUCT_SENDOPT);
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;
59 EXPORT_API int msg_add_syncml_message(msg_handle_t handle, const msg_struct_t syncml_msg)
61 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
62 msg_error_t err = MSG_SUCCESS;
64 if (handle == NULL || syncml_msg == NULL)
65 return MSG_ERR_INVALID_PARAMETER;
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);
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;
82 EXPORT_API int msg_update_message(msg_handle_t handle, const msg_struct_t opq_msg, const msg_struct_t send_opt)
84 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
85 msg_error_t err = MSG_SUCCESS;
87 if (handle == NULL || opq_msg == NULL || send_opt == NULL)
88 return MSG_ERR_INVALID_PARAMETER;
90 MsgHandle* pHandle = (MsgHandle*)handle;
92 msg_struct_s *pMsgStruct = (msg_struct_s *)opq_msg;
93 MSG_TYPE_CHECK(pMsgStruct->type, MSG_STRUCT_MESSAGE_INFO);
95 msg_struct_s* pStruct = (msg_struct_s *)send_opt;
96 MSG_TYPE_CHECK(pStruct->type, MSG_STRUCT_SENDOPT);
98 MSG_MESSAGE_HIDDEN_S *msg = (MSG_MESSAGE_HIDDEN_S *)pMsgStruct->data;
99 MSG_SENDINGOPT_S *sendingOpt = (MSG_SENDINGOPT_S *)pStruct->data;
102 err = pHandle->updateMessage(msg, sendingOpt);
103 } catch (MsgException& e) {
104 MSG_FATAL("%s", e.what());
105 return MSG_ERR_STORAGE_ERROR;
112 EXPORT_API int msg_update_read_status(msg_handle_t handle, msg_message_id_t msg_id, bool read)
114 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
115 msg_error_t err = MSG_SUCCESS;
118 return MSG_ERR_INVALID_PARAMETER;
120 MsgHandle* pHandle = (MsgHandle*)handle;
123 err = pHandle->updateReadStatus(msg_id, read);
124 } catch (MsgException& e) {
125 MSG_FATAL("%s", e.what());
126 return MSG_ERR_STORAGE_ERROR;
133 EXPORT_API int msg_set_conversation_to_read(msg_handle_t handle, msg_thread_id_t thread_id)
135 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
136 msg_error_t err = MSG_SUCCESS;
139 return MSG_ERR_INVALID_PARAMETER;
141 MsgHandle* pHandle = (MsgHandle*)handle;
144 err = pHandle->setConversationToRead(thread_id);
145 } catch (MsgException& e) {
146 MSG_FATAL("%s", e.what());
147 return MSG_ERR_STORAGE_ERROR;
154 EXPORT_API int msg_update_protected_status(msg_handle_t handle, msg_message_id_t msg_id, bool is_protected)
156 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
157 msg_error_t err = MSG_SUCCESS;
160 return MSG_ERR_INVALID_PARAMETER;
162 MsgHandle* pHandle = (MsgHandle*)handle;
165 err = pHandle->updateProtectedStatus(msg_id, is_protected);
166 } catch (MsgException& e) {
167 MSG_FATAL("%s", e.what());
168 return MSG_ERR_STORAGE_ERROR;
174 EXPORT_API int msg_delete_message(msg_handle_t handle, msg_message_id_t msg_id)
176 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
177 msg_error_t err = MSG_SUCCESS;
180 return MSG_ERR_INVALID_PARAMETER;
182 MsgHandle* pHandle = (MsgHandle*)handle;
185 err = pHandle->deleteMessage(msg_id);
186 } catch (MsgException& e) {
187 MSG_FATAL("%s", e.what());
188 return MSG_ERR_STORAGE_ERROR;
195 EXPORT_API int msg_delete_all_msgs_in_folder(msg_handle_t handle, msg_folder_id_t folder_id, bool bOnlyDB)
197 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
198 msg_error_t err = MSG_SUCCESS;
201 return MSG_ERR_INVALID_PARAMETER;
203 MsgHandle* pHandle = (MsgHandle*)handle;
206 err = pHandle->deleteAllMessagesInFolder(folder_id, bOnlyDB);
207 } catch (MsgException& e) {
208 MSG_FATAL("%s", e.what());
209 return MSG_ERR_STORAGE_ERROR;
216 EXPORT_API int msg_delete_msgs_by_list(msg_handle_t handle, msg_id_list_s *msg_id_list)
218 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
219 msg_error_t err = MSG_SUCCESS;
221 if (handle == NULL || msg_id_list == NULL)
222 return MSG_ERR_INVALID_PARAMETER;
224 MsgHandle* pHandle = (MsgHandle*)handle;
227 err = pHandle->deleteMessagesByList(msg_id_list);
228 } catch (MsgException& e) {
229 MSG_FATAL("%s", e.what());
230 return MSG_ERR_STORAGE_ERROR;
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)
239 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
240 msg_error_t err = MSG_SUCCESS;
243 return MSG_ERR_INVALID_PARAMETER;
245 MsgHandle* pHandle = (MsgHandle*)handle;
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;
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)
260 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
261 msg_error_t err = MSG_SUCCESS;
264 return MSG_ERR_INVALID_PARAMETER;
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;
271 MsgHandle* pHandle = (MsgHandle*)handle;
274 err = pHandle->moveMessageToStorage(msg_id, storage_id);
275 } catch (MsgException& e) {
276 MSG_FATAL("%s", e.what());
277 return MSG_ERR_STORAGE_ERROR;
284 EXPORT_API int msg_count_message(msg_handle_t handle, msg_folder_id_t folder_id, msg_struct_t count_info)
286 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
287 msg_error_t err = MSG_SUCCESS;
289 if (handle == NULL || count_info == NULL)
290 return MSG_ERR_INVALID_PARAMETER;
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);
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;
307 EXPORT_API int msg_count_msg_by_type(msg_handle_t handle, msg_message_type_t msg_type, int *msg_count)
309 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
310 msg_error_t err = MSG_SUCCESS;
312 if (handle == NULL || msg_count == NULL)
313 return MSG_ERR_INVALID_PARAMETER;
315 MsgHandle* pHandle = (MsgHandle*)handle;
317 MSG_MESSAGE_TYPE_S msgType = {0};
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;
329 return MSG_ERR_INVALID_PARAMETER;
333 err = pHandle->countMsgByType(&msgType, msg_count);
334 } catch (MsgException& e) {
335 MSG_FATAL("%s", e.what());
336 return MSG_ERR_STORAGE_ERROR;
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)
345 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
346 msg_error_t err = MSG_SUCCESS;
348 if (handle == NULL || addr_info == NULL || msg_thread_count_list == NULL)
349 return MSG_ERR_INVALID_PARAMETER;
351 MsgHandle* pHandle = (MsgHandle*)handle;
353 msg_struct_s *pAddr = (msg_struct_s *)addr_info;
354 MSG_TYPE_CHECK(pAddr->type, MSG_STRUCT_THREAD_LIST_INDEX);
356 msg_struct_s *pCount = (msg_struct_s *)msg_thread_count_list;
357 MSG_TYPE_CHECK(pCount->type, MSG_STRUCT_THREAD_COUNT_INFO);
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;
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)
372 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
373 msg_error_t err = MSG_SUCCESS;
375 if (handle == NULL || opq_msg == NULL || send_opt == NULL)
376 return MSG_ERR_INVALID_PARAMETER;
378 MsgHandle* pHandle = (MsgHandle*)handle;
380 msg_struct_s *pMsgStruct = (msg_struct_s *)opq_msg;
381 MSG_TYPE_CHECK(pMsgStruct->type, MSG_STRUCT_MESSAGE_INFO);
383 msg_struct_s *pStruct = (msg_struct_s *)send_opt;
384 MSG_TYPE_CHECK(pStruct->type, MSG_STRUCT_SENDOPT);
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;
396 EXPORT_API int msg_get_vobject_data(msg_handle_t handle, msg_message_id_t msg_id, void** result_data)
398 MSG_WARN(DEPRECATED_STRING_FORMAT, __FUNCTION__);
399 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
400 msg_error_t err = MSG_SUCCESS;
402 if (handle == NULL || result_data == NULL) {
403 MSG_FATAL("handle or result_data is NULL");
404 return MSG_ERR_INVALID_PARAMETER;
407 MsgHandle* pHandle = (MsgHandle*)handle;
410 err = pHandle->getVobject(msg_id, result_data);
411 } catch (MsgException& e) {
412 MSG_FATAL("%s", e.what());
413 return MSG_ERR_STORAGE_ERROR;
419 EXPORT_API int msg_get_conversation(msg_handle_t handle, msg_message_id_t msg_id, msg_struct_t conv)
421 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
422 msg_error_t err = MSG_SUCCESS;
424 if (handle == NULL || conv == NULL) {
425 MSG_FATAL("handle or opq_msg is NULL");
426 return MSG_ERR_INVALID_PARAMETER;
429 MsgHandle* pHandle = (MsgHandle*)handle;
431 msg_struct_s *pMsgStruct = (msg_struct_s *)conv;
432 MSG_TYPE_CHECK(pMsgStruct->type, MSG_STRUCT_CONV_INFO);
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;
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)
446 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
447 msg_error_t err = MSG_SUCCESS;
449 if (handle == NULL || msg_thread_view_list == NULL)
450 return MSG_ERR_INVALID_PARAMETER;
452 MsgHandle* pHandle = (MsgHandle*)handle;
453 msg_struct_s *pStruct =(msg_struct_s *)sort_rule;
455 MSG_TYPE_CHECK(pStruct->type, MSG_STRUCT_SORT_RULE);
458 if (pStruct == NULL) {
459 MSG_SORT_RULE_S sortRule = {0};
461 sortRule.sortType = MSG_SORT_BY_THREAD_DATE;
462 sortRule.bAscending = false;
464 err = pHandle->getThreadViewList(&sortRule, NULL, msg_thread_view_list);
466 err = pHandle->getThreadViewList((MSG_SORT_RULE_S *)pStruct->data, NULL, msg_thread_view_list);
468 } catch (MsgException& e) {
469 MSG_FATAL("%s", e.what());
470 return MSG_ERR_STORAGE_ERROR;
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)
479 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
480 msg_error_t err = MSG_SUCCESS;
482 if (handle == NULL || msg_thread_view_list == NULL)
483 return MSG_ERR_INVALID_PARAMETER;
485 MsgHandle* pHandle = (MsgHandle*)handle;
486 msg_struct_s *pCondition =(msg_struct_s *)msg_list_conditions;
488 MSG_TYPE_CHECK(pCondition->type, MSG_STRUCT_MSG_LIST_CONDITION);
490 MSG_LIST_CONDITION_S *pListCond = pCondition ? (MSG_LIST_CONDITION_S *)pCondition->data : NULL;
493 MSG_SORT_RULE_S sortRule = {0};
495 sortRule.sortType = MSG_SORT_BY_THREAD_DATE;
496 sortRule.bAscending = false;
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;
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)
510 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
511 msg_error_t err = MSG_SUCCESS;
513 if (handle == NULL || msg_conv_view_list == NULL)
514 return MSG_ERR_INVALID_PARAMETER;
516 MsgHandle* pHandle = (MsgHandle*)handle;
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;
529 EXPORT_API int msg_delete_thread_message_list(msg_handle_t handle, msg_thread_id_t thread_id, bool include_protected_msg)
531 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
532 msg_error_t err = MSG_SUCCESS;
535 return MSG_ERR_INVALID_PARAMETER;
537 MsgHandle* pHandle = (MsgHandle*)handle;
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;
550 EXPORT_API int msg_add_folder(msg_handle_t handle, const msg_struct_t folder_info)
552 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
553 msg_error_t err = MSG_SUCCESS;
555 if (handle == NULL || folder_info == NULL)
556 return MSG_ERR_INVALID_PARAMETER;
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);
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;
573 EXPORT_API int msg_update_folder(msg_handle_t handle, const msg_struct_t folder_info)
575 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
576 msg_error_t err = MSG_SUCCESS;
578 if (handle == NULL || folder_info == NULL)
579 return MSG_ERR_INVALID_PARAMETER;
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);
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;
596 EXPORT_API int msg_delete_folder(msg_handle_t handle, msg_folder_id_t folder_id)
598 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
599 msg_error_t err = MSG_SUCCESS;
602 return MSG_ERR_INVALID_PARAMETER;
604 MsgHandle* pHandle = (MsgHandle*)handle;
607 err = pHandle->deleteFolder(folder_id);
608 } catch (MsgException& e) {
609 MSG_FATAL("%s", e.what());
610 return MSG_ERR_STORAGE_ERROR;
617 EXPORT_API int msg_get_folder_list(msg_handle_t handle, msg_struct_list_s *folder_list)
619 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
620 msg_error_t err = MSG_SUCCESS;
622 if (handle == NULL || folder_list == NULL)
623 return MSG_ERR_INVALID_PARAMETER;
625 MsgHandle* pHandle = (MsgHandle*)handle;
628 err = pHandle->getFolderList(folder_list);
629 } catch (MsgException& e) {
630 MSG_FATAL("%s", e.what());
631 return MSG_ERR_STORAGE_ERROR;
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)
640 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
642 if (handle == NULL) {
643 MSG_DEBUG("Handle is NULL");
644 return MSG_ERR_INVALID_PARAMETER;
647 if (msg_type >= MSG_MESSAGE_TYPE_MAX) {
648 MSG_DEBUG("msg_type is invalid [%d]", msg_type);
649 return MSG_ERR_INVALID_PARAMETER;
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;
658 MSG_DEBUG("type : %d, folder : %d, num_msg : %d", msg_type, folder_id, num_msg);
661 MSG_SENDINGOPT_S sendingOpt = {0};
662 sendingOpt.bSetting = false;
664 char strMsg[20] = {0};
665 char prefix[10] ="0103001";
666 /* int postfix = 8111; */
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;
676 for (unsigned int i = 0; i < num_msg; i++) {
677 msg_s = (msg_struct_s *)msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
679 return MSG_ERR_NOT_SUPPORTED;
681 msgInfo = (MSG_MESSAGE_HIDDEN_S *)msg_s->data;
683 msgInfo->folderId = folder_id;
685 if (msg_type == MSG_TYPE_MMS) {
686 msgInfo->mainType = MSG_MMS_TYPE;
687 msgInfo->subType = MSG_SENDREQ_MMS;
689 msgInfo->mainType = MSG_SMS_TYPE;
690 msgInfo->subType = MSG_NORMAL_SMS;
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';
699 msgInfo->storageId = MSG_STORAGE_PHONE;
701 msgInfo->addr_list->nCount = 1;
703 addr_s = (msg_struct_s *)msgInfo->addr_list->msg_struct_info[0];
705 addrInfo = (MSG_ADDRESS_INFO_S *)addr_s->data;
707 addrInfo->addressType = MSG_ADDRESS_TYPE_PLMN;
708 postfix = random()%10000;
709 snprintf(addrInfo->addressVal, MAX_ADDRESS_VAL_LEN+1, "%s%04d", prefix, postfix);
711 addrInfo->recipientType = MSG_RECIPIENTS_TYPE_TO;
713 time(&(msgInfo->displayTime));
715 msgInfo->networkStatus = MSG_NETWORK_NOT_SEND;
716 msgInfo->bRead = false;
717 msgInfo->bProtected = false;
718 msgInfo->priority = MSG_MESSAGE_PRIORITY_NORMAL;
720 if (folder_id == MSG_OUTBOX_ID || folder_id == MSG_SENTBOX_ID)
721 msgInfo->direction = MSG_DIRECTION_TYPE_MO;
723 msgInfo->direction = MSG_DIRECTION_TYPE_MT;
725 if (msg_type == MSG_TYPE_MMS) {
726 snprintf(msgInfo->subject, MAX_SUBJECT_LEN+1, "subject %d", i);
728 if (folder_id == MSG_INBOX_ID)
729 msgInfo->networkStatus = MSG_NETWORK_RETRIEVE_SUCCESS;
731 msg_struct_t mms_data = msg_create_struct(MSG_STRUCT_MMS);
733 msg_set_mms_struct((msg_struct_t)msg_s, mms_data);
735 msg_release_struct(&mms_data);
738 /*err = msg_add_message(handle, (msg_message_t)&msgInfo, &sendingOpt);*/
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;
748 msg_release_struct((msg_struct_t *)&msg_s);
751 MSG_DEBUG("err [%d]", err);
760 EXPORT_API int msg_get_quick_panel_data(msg_handle_t handle, msg_quickpanel_type_t type, msg_struct_t opq_msg)
762 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
763 msg_error_t err = MSG_SUCCESS;
765 if (handle == NULL || opq_msg == NULL) {
766 MSG_FATAL("handle or opq_msg is NULL");
767 return MSG_ERR_INVALID_PARAMETER;
770 if (type > MSG_QUICKPANEL_MMS_NOTI) {
771 MSG_FATAL("unsupported quickpanel type [%d]", type);
772 return MSG_ERR_INVALID_PARAMETER;
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);
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;
790 EXPORT_API int msg_reset_database(msg_handle_t handle)
792 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
793 msg_error_t err = MSG_SUCCESS;
796 return MSG_ERR_INVALID_PARAMETER;
798 MsgHandle* pHandle = (MsgHandle*)handle;
801 err = pHandle->resetDatabase();
802 } catch (MsgException& e) {
803 MSG_FATAL("%s", e.what());
804 return MSG_ERR_STORAGE_ERROR;
811 EXPORT_API int msg_get_mem_size(msg_handle_t handle, unsigned int* memsize)
813 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
814 msg_error_t err = MSG_SUCCESS;
816 if (handle == NULL || memsize == NULL)
817 return MSG_ERR_INVALID_PARAMETER;
819 MsgHandle* pHandle = (MsgHandle*)handle;
822 err = pHandle->getMemSize(memsize);
823 } catch (MsgException& e) {
824 MSG_FATAL("%s", e.what());
825 return MSG_ERR_STORAGE_ERROR;
831 EXPORT_API int msg_backup_message(msg_handle_t handle, msg_message_backup_type_t type, const char *backup_filepath)
833 MSG_WARN(DEPRECATED_STRING_FORMAT, __FUNCTION__);
834 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
835 msg_error_t err = MSG_SUCCESS;
837 if (handle == NULL || backup_filepath == NULL)
838 return MSG_ERR_INVALID_PARAMETER;
840 MsgHandle* pHandle = (MsgHandle*)handle;
843 err = pHandle->backupMessage(type, backup_filepath);
844 } catch (MsgException& e) {
845 MSG_FATAL("%s", e.what());
846 return MSG_ERR_STORAGE_ERROR;
853 EXPORT_API int msg_restore_message(msg_handle_t handle, const char *backup_filepath)
855 MSG_WARN(DEPRECATED_STRING_FORMAT, __FUNCTION__);
856 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
857 msg_error_t err = MSG_SUCCESS;
859 if (handle == NULL || backup_filepath == NULL)
860 return MSG_ERR_INVALID_PARAMETER;
862 MsgHandle* pHandle = (MsgHandle*)handle;
865 err = pHandle->restoreMessage(backup_filepath);
866 } catch (MsgException& e) {
867 MSG_FATAL("%s", e.what());
868 return MSG_ERR_STORAGE_ERROR;
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)
877 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
878 msg_error_t err = MSG_SUCCESS;
880 if (handle == NULL || search_string == NULL || msg_thread_view_list == NULL)
881 return MSG_ERR_INVALID_PARAMETER;
883 if (strlen(search_string) <= 0 || strlen(search_string) > MAX_MSG_TEXT_LEN)
884 return MSG_ERR_INVALID_PARAMETER;
886 MsgHandle* pHandle = (MsgHandle*)handle;
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;
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)
901 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
902 msg_error_t err = MSG_SUCCESS;
904 if (handle == NULL || query == NULL || db_res == NULL || row_count == NULL || col_count == NULL)
905 return MSG_ERR_INVALID_PARAMETER;
907 MsgHandle* pHandle = (MsgHandle*)handle;
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;
920 EXPORT_API int msg_db_free(msg_handle_t handle, char **db_res)
922 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
924 if (handle == NULL || db_res == NULL)
925 return MSG_ERR_INVALID_PARAMETER;
927 MsgHandle* pHandle = (MsgHandle*)handle;
930 pHandle->dbFree(db_res);
931 } catch (MsgException& e) {
932 MSG_FATAL("%s", e.what());
933 return MSG_ERR_STORAGE_ERROR;
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)
943 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
944 msg_error_t err = MSG_SUCCESS;
946 if (handle == NULL || msg_reject_msg_list == NULL)
947 return MSG_ERR_INVALID_PARAMETER;
949 MsgHandle* pHandle = (MsgHandle*)handle;
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;
962 EXPORT_API int msg_reg_storage_change_callback(msg_handle_t handle, msg_storage_change_cb cb, void *user_param)
964 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
965 msg_error_t err = MSG_SUCCESS;
967 if (handle == NULL || cb == NULL)
968 return MSG_ERR_INVALID_PARAMETER;
970 MsgHandle* pHandle = (MsgHandle*)handle;
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;
979 return MSG_ERR_CALLBACK_ERROR;
985 EXPORT_API int msg_reg_thread_change_callback(msg_handle_t handle, msg_thread_change_cb cb, void *user_param)
987 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
988 msg_error_t err = MSG_SUCCESS;
990 if (handle == NULL || cb == NULL)
991 return MSG_ERR_INVALID_PARAMETER;
993 MsgHandle* pHandle = (MsgHandle*)handle;
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;
1002 return MSG_ERR_CALLBACK_ERROR;
1009 EXPORT_API int msg_get_report_status(msg_handle_t handle, msg_message_id_t msg_id, msg_struct_list_s *report_list)
1011 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
1012 msg_error_t err = MSG_SUCCESS;
1014 if (handle == NULL || msg_id < 1 || report_list == NULL)
1015 return MSG_ERR_INVALID_PARAMETER;
1017 MsgHandle* pHandle = (MsgHandle*)handle;
1020 err = pHandle->getReportStatus(msg_id, report_list);
1021 } catch (MsgException& e) {
1022 MSG_FATAL("%s", e.what());
1023 return MSG_ERR_STORAGE_ERROR;
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)
1031 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
1032 msg_error_t err = MSG_SUCCESS;
1034 if (handle == NULL || msg_address_list == NULL)
1035 return MSG_ERR_INVALID_PARAMETER;
1037 MsgHandle* pHandle = (MsgHandle*)handle;
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;
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)
1052 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
1053 msg_error_t err = MSG_SUCCESS;
1055 if (handle == NULL || msg_address_list == NULL || thread_id == NULL) {
1056 return MSG_ERR_INVALID_PARAMETER;
1059 if (msg_address_list->nCount < 1 )
1060 return MSG_ERR_INVALID_PARAMETER;
1062 MsgHandle* pHandle = (MsgHandle*)handle;
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;
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)
1077 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
1078 msg_error_t err = MSG_SUCCESS;
1080 if (handle == NULL || msg_address_list == NULL || thread_id == NULL)
1081 return MSG_ERR_INVALID_PARAMETER;
1083 MsgHandle* pHandle = (MsgHandle*)handle;
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;
1096 EXPORT_API int msg_get_thread(msg_handle_t handle, msg_thread_id_t thread_id, msg_struct_t msg_thread)
1098 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
1099 msg_error_t err = MSG_SUCCESS;
1101 if (handle == NULL || msg_thread == NULL) {
1102 MSG_FATAL("handle or msg_thread is NULL");
1103 return MSG_ERR_INVALID_PARAMETER;
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);
1110 MSG_THREAD_VIEW_S* pThreadInfo = (MSG_THREAD_VIEW_S *)msgThread->data;
1113 err = pHandle->getThread(thread_id, pThreadInfo);
1114 } catch (MsgException& e) {
1115 MSG_FATAL("%s", e.what());
1116 return MSG_ERR_STORAGE_ERROR;
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)
1124 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
1125 msg_error_t err = MSG_SUCCESS;
1127 if (handle == NULL || msg_list_conditions == NULL || msg_list == NULL)
1128 return MSG_ERR_INVALID_PARAMETER;
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);
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;
1144 EXPORT_API int msg_get_media_list(msg_handle_t handle, msg_thread_id_t thread_id, msg_list_handle_t *msg_list)
1146 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_MMS_FEATURE);
1147 msg_error_t err = MSG_SUCCESS;
1149 if (handle == NULL || msg_list == NULL)
1150 return MSG_ERR_INVALID_PARAMETER;
1152 MsgHandle* pHandle = (MsgHandle*)handle;
1155 err = pHandle->getMediaList(thread_id, msg_list);
1156 } catch (MsgException& e) {
1157 MSG_FATAL("%s", e.what());
1158 return MSG_ERR_STORAGE_ERROR;
1165 static int msg_get_msg_type(int mainType, int subType)
1167 if (mainType == MSG_SMS_TYPE) {
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;
1182 return MSG_TYPE_SMS_SYNCML;
1183 case MSG_REJECT_SMS:
1184 return MSG_TYPE_SMS_REJECT;
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;
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;
1202 return MSG_TYPE_SMS;
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;
1210 return MSG_TYPE_MMS;
1212 return MSG_TYPE_INVALID;
1217 int msg_syncml_info_get_int(void *syncml_info, int field, int *value)
1220 return MSG_ERR_NULL_POINTER;
1222 int ret = MSG_SUCCESS;
1224 MSG_SYNCML_MESSAGE_S *pSync = (MSG_SYNCML_MESSAGE_S *)syncml_info;
1227 case MSG_SYNCML_INFO_EXTID_INT:
1228 *value = pSync->extId;
1230 case MSG_SYNCML_INFO_PINCODE_INT:
1231 *value = pSync->pinCode;
1234 ret = MSG_ERR_INVALID_PARAMETER;
1241 int msg_count_info_get_int(void *count_info, int field, int *value)
1244 return MSG_ERR_NULL_POINTER;
1246 int ret = MSG_SUCCESS;
1248 MSG_COUNT_INFO_S *pCount = (MSG_COUNT_INFO_S *)count_info;
1251 case MSG_COUNT_INFO_READ_INT:
1252 *value = pCount->nReadCnt;
1254 case MSG_COUNT_INFO_UNREAD_INT:
1255 *value = pCount->nUnreadCnt;
1257 case MSG_COUNT_INFO_SMS_INT:
1258 *value = pCount->nSms;
1260 case MSG_COUNT_INFO_MMS_INT:
1261 *value = pCount->nMms;
1264 ret = MSG_ERR_INVALID_PARAMETER;
1271 int msg_thread_count_get_int(void *count_info, int field, int *value)
1274 return MSG_ERR_NULL_POINTER;
1276 int ret = MSG_SUCCESS;
1278 MSG_THREAD_COUNT_INFO_S *pCount = (MSG_THREAD_COUNT_INFO_S *)count_info;
1281 case MSG_THREAD_COUNT_TOTAL_INT:
1282 *value = pCount->totalCount;
1284 case MSG_THREAD_COUNT_UNREAD_INT:
1285 *value = pCount->unReadCount;
1287 case MSG_THREAD_COUNT_SMS_INT:
1288 *value = pCount->smsMsgCount;
1290 case MSG_THREAD_COUNT_MMS_INT:
1291 *value = pCount->mmsMsgCount;
1294 ret = MSG_ERR_INVALID_PARAMETER;
1301 int msg_thread_index_get_int(void *index_info, int field, int *value)
1304 return MSG_ERR_NULL_POINTER;
1306 int ret = MSG_SUCCESS;
1308 MSG_THREAD_LIST_INDEX_S *pIndex = (MSG_THREAD_LIST_INDEX_S *)index_info;
1310 case MSG_THREAD_LIST_INDEX_CONTACTID_INT:
1311 *value = pIndex->contactId;
1314 ret = MSG_ERR_INVALID_PARAMETER;
1321 int msg_sortrule_get_int(void *sort_info, int field, int *value)
1324 return MSG_ERR_NULL_POINTER;
1326 int ret = MSG_SUCCESS;
1328 MSG_SORT_RULE_S *pSort = (MSG_SORT_RULE_S *)sort_info;
1331 case MSG_SORT_RULE_SORT_TYPE_INT:
1332 *value = pSort->sortType;
1335 ret = MSG_ERR_INVALID_PARAMETER;
1342 int msg_folder_info_get_int(void *folder_info, int field, int *value)
1345 return MSG_ERR_NULL_POINTER;
1347 int ret = MSG_SUCCESS;
1349 MSG_FOLDER_INFO_S *pFolder = (MSG_FOLDER_INFO_S *)folder_info;
1352 case MSG_FOLDER_INFO_ID_INT:
1353 *value = pFolder->folderId;
1355 case MSG_FOLDER_INFO_TYPE_INT:
1356 *value = pFolder->folderType;
1359 ret = MSG_ERR_INVALID_PARAMETER;
1366 int msg_thread_info_get_int(void *data, int field, int *value)
1369 return MSG_ERR_NULL_POINTER;
1371 int ret = MSG_SUCCESS;
1373 MSG_THREAD_VIEW_S *pThread = (MSG_THREAD_VIEW_S *)data;
1376 case MSG_THREAD_ID_INT:
1377 *value = pThread->threadId;
1379 case MSG_THREAD_MSG_TYPE_INT:
1380 *value = msg_get_msg_type(pThread->mainType, pThread->subType);
1382 case MSG_THREAD_MSG_TIME_INT:
1383 *value = pThread->threadTime;
1385 case MSG_THREAD_DIRECTION_INT:
1386 *value = pThread->direction;
1388 case MSG_THREAD_UNREAD_COUNT_INT:
1389 *value = pThread->unreadCnt;
1391 case MSG_THREAD_SMS_COUNT_INT:
1392 *value = pThread->smsCnt;
1394 case MSG_THREAD_MMS_COUNT_INT:
1395 *value = pThread->mmsCnt;
1398 ret = MSG_ERR_INVALID_PARAMETER;
1406 int msg_conv_info_get_int(void *data, int field, int *value)
1409 return MSG_ERR_NULL_POINTER;
1411 int ret = MSG_SUCCESS;
1413 MSG_CONVERSATION_VIEW_S *pConv = (MSG_CONVERSATION_VIEW_S *)data;
1416 case MSG_CONV_MSG_ID_INT:
1417 *value = pConv->msgId;
1419 case MSG_CONV_MSG_THREAD_ID_INT:
1420 *value = pConv->threadId;
1422 case MSG_CONV_MSG_FOLDER_ID_INT:
1423 *value = pConv->folderId;
1425 case MSG_CONV_MSG_TYPE_INT:
1426 *value = msg_get_msg_type(pConv->mainType, pConv->subType);
1428 case MSG_CONV_MSG_STORAGE_ID_INT:
1429 *value = pConv->storageId;
1431 case MSG_CONV_MSG_DISPLAY_TIME_INT:
1432 *value = pConv->displayTime;
1434 case MSG_CONV_MSG_SCHEDULED_TIME_INT:
1435 *value = pConv->scheduledTime;
1437 case MSG_CONV_MSG_NETWORK_STATUS_INT:
1438 *value = pConv->networkStatus;
1440 case MSG_CONV_MSG_DIRECTION_INT:
1441 *value = pConv->direction;
1443 case MSG_CONV_MSG_ATTACH_COUNT_INT:
1444 *value = pConv->attachCount;
1446 case MSG_CONV_MSG_TEXT_SIZE_INT:
1447 *value = pConv->textSize;
1449 case MSG_CONV_MSG_PAGE_COUNT_INT:
1450 *value = pConv->pageCount;
1452 case MSG_CONV_MSG_TCS_BC_LEVEL_INT:
1453 *value = pConv->tcs_bc_level;
1455 case MSG_CONV_MSG_SIM_INDEX_INT:
1456 *value = pConv->simIndex;
1459 ret = MSG_ERR_INVALID_PARAMETER;
1467 int msg_list_condition_get_int(void *condition_info, int field, int *value)
1469 if (!condition_info)
1470 return MSG_ERR_NULL_POINTER;
1472 int ret = MSG_SUCCESS;
1474 MSG_LIST_CONDITION_S *pCond = (MSG_LIST_CONDITION_S *)condition_info;
1477 case MSG_LIST_CONDITION_FOLDER_ID_INT:
1478 *value = pCond->folderId;
1480 case MSG_LIST_CONDITION_THREAD_ID_INT:
1481 *value = pCond->threadId;
1483 case MSG_LIST_CONDITION_STORAGE_ID_INT:
1484 *value = pCond->storageId;
1486 case MSG_LIST_CONDITION_MSGTYPE_INT:
1487 *value = pCond->msgType;
1489 case MSG_LIST_CONDITION_FROM_TIME_INT:
1490 *value = pCond->fromTime;
1492 case MSG_LIST_CONDITION_TO_TIME_INT:
1493 *value = pCond->toTime;
1495 case MSG_LIST_CONDITION_OFFSET_INT:
1496 *value = pCond->offset;
1498 case MSG_LIST_CONDITION_LIMIT_INT:
1499 *value = pCond->limit;
1501 case MSG_LIST_CONDITION_SIM_INDEX_INT:
1502 *value = pCond->simIndex;
1505 ret = MSG_ERR_INVALID_PARAMETER;
1513 int msg_report_status_get_int(void *report_info, int field, int *value)
1516 return MSG_ERR_NULL_POINTER;
1518 int ret = MSG_SUCCESS;
1520 MSG_REPORT_STATUS_INFO_S *pReport = (MSG_REPORT_STATUS_INFO_S *)report_info;
1522 case MSG_REPORT_TYPE_INT:
1523 *value = pReport->type;
1525 case MSG_REPORT_STATUS_INT:
1526 *value = pReport->status;
1528 case MSG_REPORT_TIME_INT:
1529 *value = pReport->statusTime;
1532 ret = MSG_ERR_INVALID_PARAMETER;
1539 int msg_report_status_get_str(void *report_info, int field, char *value, int size)
1542 return MSG_ERR_NULL_POINTER;
1544 MSG_REPORT_STATUS_INFO_S *pReport = (MSG_REPORT_STATUS_INFO_S *)report_info;
1547 case MSG_REPORT_ADDRESS_STR:
1548 strncpy(value, pReport->addressVal, size);
1551 return MSG_ERR_INVALID_PARAMETER;
1556 int msg_folder_info_get_str(void *folder_info, int field, char *value, int size)
1559 return MSG_ERR_NULL_POINTER;
1561 MSG_FOLDER_INFO_S *pFolder = (MSG_FOLDER_INFO_S *)folder_info;
1564 case MSG_FOLDER_INFO_NAME_STR:
1565 strncpy(value, pFolder->folderName, size);
1568 return MSG_ERR_INVALID_PARAMETER;
1574 int msg_thread_info_get_str(void *data, int field, char *value, int size)
1577 return MSG_ERR_NULL_POINTER;
1579 MSG_THREAD_VIEW_S *pThread = (MSG_THREAD_VIEW_S *)data;
1582 case MSG_THREAD_NAME_STR:
1583 strncpy(value, pThread->threadName, size);
1585 case MSG_THREAD_MSG_DATA_STR:
1586 strncpy(value, pThread->threadData, size);
1589 return MSG_ERR_INVALID_PARAMETER;
1596 int msg_conv_info_get_str(void *data, int field, char *value, int size)
1599 return MSG_ERR_NULL_POINTER;
1601 MSG_CONVERSATION_VIEW_S *pConv = (MSG_CONVERSATION_VIEW_S *)data;
1604 case MSG_CONV_MSG_SUBJECT_STR:
1605 strncpy(value, pConv->subject, size);
1607 case MSG_CONV_MSG_ATTACH_NAME_STR:
1608 strncpy(value, pConv->attachFileName, size);
1610 case MSG_CONV_MSG_AUDIO_NAME_STR:
1611 strncpy(value, pConv->audioFileName, size);
1613 case MSG_CONV_MSG_IMAGE_THUMB_PATH_STR:
1614 strncpy(value, pConv->imageThumbPath, size);
1616 case MSG_CONV_MSG_VIDEO_THUMB_PATH_STR:
1617 strncpy(value, pConv->videoThumbPath, size);
1619 case MSG_CONV_MSG_TEXT_STR:
1621 strncpy(value, pConv->pText, size);
1623 case MSG_CONV_MSG_1ST_MEDIA_PATH_STR:
1624 strncpy(value, pConv->firstMediaPath, size);
1627 return MSG_ERR_INVALID_PARAMETER;
1634 int msg_list_condition_get_str(void *condition_info, int field, char *value, int size)
1636 if (!condition_info)
1637 return MSG_ERR_NULL_POINTER;
1639 MSG_LIST_CONDITION_S *cond = (MSG_LIST_CONDITION_S *)condition_info;
1642 case MSG_LIST_CONDITION_ADDRESS_VALUE_STR:
1643 if (cond->pAddressVal)
1644 strncpy(value, cond->pAddressVal, size);
1646 case MSG_LIST_CONDITION_TEXT_VALUE_STR:
1648 strncpy(value, cond->pTextVal, size);
1651 return MSG_ERR_INVALID_PARAMETER;
1658 int msg_sendopt_get_bool(void *send_opt, int field, bool *value)
1661 return MSG_ERR_NULL_POINTER;
1663 int ret = MSG_SUCCESS;
1665 MSG_SENDINGOPT_S *sendopt = (MSG_SENDINGOPT_S *)send_opt;
1668 case MSG_SEND_OPT_SETTING_BOOL:
1669 *value = sendopt->bSetting;
1671 case MSG_SEND_OPT_KEEPCOPY_BOOL:
1672 *value = sendopt->bKeepCopy;
1674 case MSG_SEND_OPT_DELIVER_REQ_BOOL:
1675 *value = sendopt->bDeliverReq;
1678 ret = MSG_ERR_INVALID_PARAMETER;
1685 int msg_sortrule_get_bool(void *sort_rule, int field, bool *value)
1688 return MSG_ERR_NULL_POINTER;
1690 int ret = MSG_SUCCESS;
1692 MSG_SORT_RULE_S *pSort = (MSG_SORT_RULE_S *)sort_rule;
1695 case MSG_SORT_RULE_ACSCEND_BOOL:
1696 *value = pSort->bAscending;
1699 ret = MSG_ERR_INVALID_PARAMETER;
1706 int msg_conv_get_bool(void *data, int field, bool *value)
1709 return MSG_ERR_NULL_POINTER;
1711 int ret = MSG_SUCCESS;
1713 MSG_CONVERSATION_VIEW_S *pConv = (MSG_CONVERSATION_VIEW_S *)data;
1716 case MSG_CONV_MSG_READ_BOOL:
1717 *value = pConv->bRead;
1719 case MSG_CONV_MSG_PROTECTED_BOOL:
1720 *value = pConv->bProtected;
1722 case MSG_CONV_MSG_DPM_RESTRICTED_BOOL:
1723 *value = pConv->bRestricted;
1726 ret = MSG_ERR_INVALID_PARAMETER;
1733 int msg_thread_info_get_bool(void *data, int field, bool *value)
1736 return MSG_ERR_NULL_POINTER;
1738 int ret = MSG_SUCCESS;
1740 MSG_THREAD_VIEW_S *pthreadInfo = (MSG_THREAD_VIEW_S *)data;
1743 case MSG_THREAD_PROTECTED_BOOL:
1744 *value = pthreadInfo->bProtected;
1746 case MSG_THREAD_DRAFT_BOOL:
1747 *value = pthreadInfo->bDraft;
1749 case MSG_THREAD_SEND_FAILED_BOOL:
1750 *value = pthreadInfo->bSendFailed;
1752 case MSG_THREAD_SENDING_BOOL:
1753 *value = pthreadInfo->bSending;
1756 ret = MSG_ERR_INVALID_PARAMETER;
1764 int msg_list_condition_get_bool(void *data, int field, bool *value)
1767 return MSG_ERR_NULL_POINTER;
1769 int ret = MSG_SUCCESS;
1771 MSG_LIST_CONDITION_S *pCond = (MSG_LIST_CONDITION_S *)data;
1774 case MSG_LIST_CONDITION_PROTECTED_BOOL:
1775 *value = pCond->bProtected;
1777 case MSG_LIST_CONDITION_SCHEDULED_BOOL:
1778 *value = pCond->bScheduled;
1780 case MSG_LIST_CONDITION_AND_OPERATER_BOOL:
1781 *value = pCond->bAnd;
1784 ret = MSG_ERR_INVALID_PARAMETER;
1792 int msg_sendopt_get_struct_handle(msg_struct_s *msg_struct, int field, void **value)
1794 msg_error_t err = MSG_SUCCESS;
1796 if (!msg_struct || !value)
1797 return MSG_ERR_NULL_POINTER;
1799 MSG_SENDINGOPT_S *sendopt = (MSG_SENDINGOPT_S *)msg_struct->data;
1802 case MSG_SEND_OPT_MMS_OPT_HND:
1803 *value = (void *)sendopt->mmsSendOpt;
1805 case MSG_SEND_OPT_SMS_OPT_HND:
1806 *value = (void *)sendopt->smsSendOpt;
1809 err = MSG_ERR_INVALID_PARAMETER;
1816 int msg_syncml_get_struct_handle(msg_struct_s *msg_struct, int field, void **value)
1818 msg_error_t err = MSG_SUCCESS;
1820 if (!msg_struct || !value)
1821 return MSG_ERR_NULL_POINTER;
1823 MSG_SYNCML_MESSAGE_S *pSync = (MSG_SYNCML_MESSAGE_S *)msg_struct->data;
1826 case MSG_SYNCML_INFO_MESSAGE_HND:
1827 *value = (void *)pSync->msg;
1830 err = MSG_ERR_INVALID_PARAMETER;
1837 int msg_thread_index_get_struct_handle(msg_struct_s *msg_struct, int field, void **value)
1839 msg_error_t err = MSG_SUCCESS;
1841 if (!msg_struct || !value)
1842 return MSG_ERR_NULL_POINTER;
1844 MSG_THREAD_LIST_INDEX_INFO_S *pIndex = (MSG_THREAD_LIST_INDEX_INFO_S *)msg_struct->data;
1847 case MSG_THREAD_LIST_INDEX_ADDR_INFO_HND:
1848 *value = (void *)pIndex->msgAddrInfo;
1851 err = MSG_ERR_INVALID_PARAMETER;
1859 int msg_list_condition_get_struct_handle(msg_struct_s *msg_struct, int field, void **value)
1861 msg_error_t err = MSG_SUCCESS;
1863 if (!msg_struct || !value)
1864 return MSG_ERR_NULL_POINTER;
1866 MSG_LIST_CONDITION_S *pCond = (MSG_LIST_CONDITION_S *)msg_struct->data;
1869 case MSG_LIST_CONDITION_SORT_RULE_HND:
1870 *value = (void *)pCond->sortRule;
1873 err = MSG_ERR_INVALID_PARAMETER;
1881 int msg_address_info_get_int(void *addr_info, int field, int *value)
1884 return MSG_ERR_NULL_POINTER;
1886 int ret = MSG_SUCCESS;
1888 MSG_ADDRESS_INFO_S *pAddr = (MSG_ADDRESS_INFO_S *)addr_info;
1891 case MSG_ADDRESS_INFO_ADDRESS_TYPE_INT:
1892 *value = pAddr->addressType;
1894 case MSG_ADDRESS_INFO_RECIPIENT_TYPE_INT:
1895 *value = pAddr->recipientType;
1897 case MSG_ADDRESS_INFO_CONTACT_ID_INT:
1898 *value = pAddr->contactId;
1901 ret = MSG_ERR_INVALID_PARAMETER;
1908 int msg_mms_sendopt_get_int(void *opt_info, int field, int *value)
1911 return MSG_ERR_NULL_POINTER;
1913 int ret = MSG_SUCCESS;
1915 MMS_SENDINGOPT_S *pOpt = (MMS_SENDINGOPT_S *)opt_info;
1918 case MSG_MMS_SENDOPTION_EXPIRY_TIME_INT:
1919 *value = pOpt->expiryTime;
1921 case MSG_MMS_SENDOPTION_DELIVERY_TIME_INT:
1922 *value = pOpt->deliveryTime;
1924 case MSG_MMS_SENDOPTION_PRIORITY_INT:
1925 *value = pOpt->priority;
1928 ret = MSG_ERR_INVALID_PARAMETER;
1935 int msg_reject_message_get_int(void *msg_info, int field, int *value)
1938 return MSG_ERR_NULL_POINTER;
1940 int ret = MSG_SUCCESS;
1942 MSG_REJECT_MSG_INFO_S *pMsg = (MSG_REJECT_MSG_INFO_S *)msg_info;
1945 case MSG_REJECT_MESSAGE_MSGID_INT:
1946 *value = pMsg->msgId;
1948 case MSG_REJECT_MESSAGE_DISPLAY_TIME_INT:
1949 *value = pMsg->displayTime;
1952 ret = MSG_ERR_INVALID_PARAMETER;
1959 int msg_address_info_get_str(void *addr_info, int field, char *value, int size)
1962 return MSG_ERR_NULL_POINTER;
1964 MSG_ADDRESS_INFO_S *pAddr = (MSG_ADDRESS_INFO_S *)addr_info;
1967 case MSG_ADDRESS_INFO_ADDRESS_VALUE_STR:
1968 strncpy(value, pAddr->addressVal, size);
1970 case MSG_ADDRESS_INFO_DISPLAYNAME_STR:
1971 strncpy(value, pAddr->displayName, size);
1974 return MSG_ERR_INVALID_PARAMETER;
1980 int msg_reject_message_get_str(void *msg_info, int field, char *value, int size)
1983 return MSG_ERR_NULL_POINTER;
1985 MSG_REJECT_MSG_INFO_S *pMsg = (MSG_REJECT_MSG_INFO_S *)msg_info;
1988 case MSG_REJECT_MESSAGE_MSGTEXT_STR:
1989 strncpy(value, pMsg->msgText, size);
1992 return MSG_ERR_INVALID_PARAMETER;
1998 int msg_mms_sendopt_get_bool(void *opt_info, int field, bool *value)
2001 return MSG_ERR_NULL_POINTER;
2003 int ret = MSG_SUCCESS;
2005 MMS_SENDINGOPT_S *pOpt = (MMS_SENDINGOPT_S *)opt_info;
2008 case MSG_MMS_SENDOPTION_READ_REQUEST_BOOL:
2009 *value = pOpt->bReadReq;
2011 case MSG_MMS_SENDOPTION_DELIVERY_CUSTOMTIME_BOOL:
2012 *value = pOpt->bUseDeliveryCustomTime;
2015 ret = MSG_ERR_INVALID_PARAMETER;
2022 int msg_sms_sendopt_get_bool(void *opt_info, int field, bool *value)
2025 return MSG_ERR_NULL_POINTER;
2027 int ret = MSG_SUCCESS;
2029 SMS_SENDINGOPT_S *pOpt = (SMS_SENDINGOPT_S *)opt_info;
2032 case MSG_SMS_SENDOPT_REPLYPATH_BOOL:
2033 *value = pOpt->bReplyPath;
2036 ret = MSG_ERR_INVALID_PARAMETER;
2043 int msg_syncml_info_set_int(void *syncml_info, int field, int value)
2045 msg_error_t err = MSG_SUCCESS;
2048 return MSG_ERR_NULL_POINTER;
2050 MSG_SYNCML_MESSAGE_S *pSync = (MSG_SYNCML_MESSAGE_S *)syncml_info;
2053 case MSG_SYNCML_INFO_EXTID_INT:
2054 pSync->extId = value;
2056 case MSG_SYNCML_INFO_PINCODE_INT:
2057 pSync->pinCode = value;
2060 err = MSG_ERR_INVALID_PARAMETER;
2067 int msg_count_info_set_int(void *count_info, int field, int value)
2069 msg_error_t err = MSG_SUCCESS;
2072 return MSG_ERR_NULL_POINTER;
2074 MSG_COUNT_INFO_S *pCount = (MSG_COUNT_INFO_S *)count_info;
2077 case MSG_COUNT_INFO_READ_INT:
2078 pCount->nReadCnt = value;
2080 case MSG_COUNT_INFO_UNREAD_INT:
2081 pCount->nUnreadCnt = value;
2083 case MSG_COUNT_INFO_SMS_INT:
2084 pCount->nSms = value;
2086 case MSG_COUNT_INFO_MMS_INT:
2087 pCount->nMms = value;
2090 err = MSG_ERR_INVALID_PARAMETER;
2097 int msg_thread_count_set_int(void *count_info, int field, int value)
2099 msg_error_t err = MSG_SUCCESS;
2102 return MSG_ERR_NULL_POINTER;
2104 MSG_THREAD_COUNT_INFO_S *pCount = (MSG_THREAD_COUNT_INFO_S *)count_info;
2107 case MSG_THREAD_COUNT_TOTAL_INT:
2108 pCount->totalCount = value;
2110 case MSG_THREAD_COUNT_UNREAD_INT:
2111 pCount->unReadCount = value;
2113 case MSG_THREAD_COUNT_SMS_INT:
2114 pCount->smsMsgCount = value;
2116 case MSG_THREAD_COUNT_MMS_INT:
2117 pCount->mmsMsgCount = value;
2120 err = MSG_ERR_INVALID_PARAMETER;
2127 int msg_thread_index_set_int(void *index_info, int field, int value)
2129 msg_error_t err = MSG_SUCCESS;
2132 return MSG_ERR_NULL_POINTER;
2134 MSG_THREAD_LIST_INDEX_S *pIndex = (MSG_THREAD_LIST_INDEX_S *)index_info;
2137 case MSG_THREAD_LIST_INDEX_CONTACTID_INT:
2138 pIndex->contactId = value;
2141 err = MSG_ERR_INVALID_PARAMETER;
2148 int msg_sortrule_set_int(void *sort_info, int field, int value)
2150 msg_error_t err = MSG_SUCCESS;
2153 return MSG_ERR_NULL_POINTER;
2155 MSG_SORT_RULE_S *pSort = (MSG_SORT_RULE_S *)sort_info;
2158 case MSG_SORT_RULE_SORT_TYPE_INT:
2159 pSort->sortType = value;
2162 err = MSG_ERR_INVALID_PARAMETER;
2169 int msg_folder_info_set_int(void *folder_info, int field, int value)
2171 msg_error_t err = MSG_SUCCESS;
2174 return MSG_ERR_NULL_POINTER;
2176 MSG_FOLDER_INFO_S *pFolder = (MSG_FOLDER_INFO_S *)folder_info;
2179 case MSG_FOLDER_INFO_ID_INT:
2180 pFolder->folderId = value;
2182 case MSG_FOLDER_INFO_TYPE_INT:
2183 pFolder->folderType = value;
2186 err = MSG_ERR_INVALID_PARAMETER;
2194 int msg_list_condition_set_int(void *condition_info, int field, int value)
2196 msg_error_t err = MSG_SUCCESS;
2198 if (!condition_info)
2199 return MSG_ERR_NULL_POINTER;
2201 MSG_LIST_CONDITION_S *pCond = (MSG_LIST_CONDITION_S *)condition_info;
2204 case MSG_LIST_CONDITION_FOLDER_ID_INT:
2205 pCond->folderId = value;
2207 case MSG_LIST_CONDITION_THREAD_ID_INT:
2208 pCond->threadId = value;
2210 case MSG_LIST_CONDITION_STORAGE_ID_INT:
2211 pCond->storageId = value;
2213 case MSG_LIST_CONDITION_MSGTYPE_INT:
2214 pCond->msgType = value;
2216 case MSG_LIST_CONDITION_FROM_TIME_INT:
2217 pCond->fromTime = value;
2219 case MSG_LIST_CONDITION_TO_TIME_INT:
2220 pCond->toTime = value;
2222 case MSG_LIST_CONDITION_OFFSET_INT:
2223 pCond->offset = value;
2225 case MSG_LIST_CONDITION_LIMIT_INT:
2226 pCond->limit = value;
2228 case MSG_LIST_CONDITION_SIM_INDEX_INT:
2229 pCond->simIndex = value;
2232 err = MSG_ERR_INVALID_PARAMETER;
2240 int msg_report_status_set_int(void *report_info, int field, int value)
2242 msg_error_t err = MSG_SUCCESS;
2245 return MSG_ERR_NULL_POINTER;
2247 MSG_REPORT_STATUS_INFO_S *pReport = (MSG_REPORT_STATUS_INFO_S *)report_info;
2250 case MSG_REPORT_TYPE_INT:
2251 pReport->type = value;
2253 case MSG_REPORT_STATUS_INT:
2254 pReport->status = value;
2256 case MSG_REPORT_TIME_INT:
2257 pReport->statusTime = value;
2260 err = MSG_ERR_INVALID_PARAMETER;
2267 int msg_folder_info_set_str(void *folder_info, int field, const char *value, int size)
2269 msg_error_t err = MSG_SUCCESS;
2271 if (!folder_info || !value)
2272 return MSG_ERR_NULL_POINTER;
2274 MSG_FOLDER_INFO_S *pFolder = (MSG_FOLDER_INFO_S *)folder_info;
2277 (size > MAX_FOLDER_NAME_SIZE)? _len = MAX_FOLDER_NAME_SIZE : _len = size;
2280 case MSG_FOLDER_INFO_NAME_STR:
2281 strncpy(pFolder->folderName, value, _len);
2284 err = MSG_ERR_INVALID_PARAMETER;
2292 int msg_list_condition_set_str(void *condition_info, int field, const char *value, int size)
2294 msg_error_t err = MSG_SUCCESS;
2296 if (!condition_info || !value)
2297 return MSG_ERR_NULL_POINTER;
2300 return MSG_ERR_INVALID_PARAMETER;
2303 MSG_LIST_CONDITION_S *cond = (MSG_LIST_CONDITION_S *)condition_info;
2306 case MSG_LIST_CONDITION_ADDRESS_VALUE_STR:
2308 if (cond->pAddressVal) {
2309 delete [] cond->pAddressVal;
2310 cond->pAddressVal = NULL;
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);
2317 return MSG_ERR_MEMORY_ERROR;
2320 case MSG_LIST_CONDITION_TEXT_VALUE_STR:
2322 if (cond->pTextVal) {
2323 delete [] cond->pTextVal;
2324 cond->pTextVal = NULL;
2326 cond->pTextVal = (char *)new char[size+1];
2327 memset(cond->pTextVal, 0x00, sizeof(char)*(size+1));
2329 memcpy(cond->pTextVal, value, sizeof(char)*size);
2331 return MSG_ERR_MEMORY_ERROR;
2335 err = MSG_ERR_INVALID_PARAMETER;
2343 int msg_sendopt_set_bool(void *send_opt, int field, bool value)
2345 msg_error_t err = MSG_SUCCESS;
2348 return MSG_ERR_NULL_POINTER;
2350 MSG_SENDINGOPT_S *sendopt = (MSG_SENDINGOPT_S *)send_opt;
2353 case MSG_SEND_OPT_SETTING_BOOL:
2354 sendopt->bSetting = value;
2356 case MSG_SEND_OPT_KEEPCOPY_BOOL:
2357 sendopt->bKeepCopy = value;
2359 case MSG_SEND_OPT_DELIVER_REQ_BOOL:
2360 sendopt->bDeliverReq = value;
2363 err = MSG_ERR_UNKNOWN;
2370 int msg_sortrule_set_bool(void *sort_rule, int field, bool value)
2372 msg_error_t err = MSG_SUCCESS;
2375 return MSG_ERR_NULL_POINTER;
2377 MSG_SORT_RULE_S *pSort = (MSG_SORT_RULE_S *)sort_rule;
2380 case MSG_SORT_RULE_ACSCEND_BOOL:
2381 pSort->bAscending = value;
2384 err = MSG_ERR_UNKNOWN;
2392 int msg_list_condition_set_bool(void *data, int field, bool value)
2394 msg_error_t err = MSG_SUCCESS;
2397 return MSG_ERR_NULL_POINTER;
2399 MSG_LIST_CONDITION_S *pCond = (MSG_LIST_CONDITION_S *)data;
2402 case MSG_LIST_CONDITION_PROTECTED_BOOL:
2403 pCond->bProtected = value;
2405 case MSG_LIST_CONDITION_SCHEDULED_BOOL:
2406 pCond->bScheduled = value;
2408 case MSG_LIST_CONDITION_AND_OPERATER_BOOL:
2409 pCond->bAnd = value;
2412 err = MSG_ERR_UNKNOWN;
2420 int msg_sendopt_set_struct_handle(msg_struct_s *msg_struct, int field, msg_struct_s *value)
2422 msg_error_t err = MSG_SUCCESS;
2424 if (!msg_struct || !value)
2425 return MSG_ERR_NULL_POINTER;
2427 MSG_SENDINGOPT_S *sendopt = (MSG_SENDINGOPT_S *)msg_struct->data;
2428 msg_struct_s *pTmp = NULL;
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));
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));
2440 err = MSG_ERR_UNKNOWN;
2447 int msg_syncml_set_struct_handle(msg_struct_s *msg_struct, int field, msg_struct_s *value)
2449 msg_error_t err = MSG_SUCCESS;
2451 if (!msg_struct || !value)
2452 return MSG_ERR_NULL_POINTER;
2454 MSG_SYNCML_MESSAGE_S *pSync = (MSG_SYNCML_MESSAGE_S *)msg_struct->data;
2455 msg_struct_s *pTmp = NULL;
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);
2466 err = MSG_ERR_UNKNOWN;
2473 int msg_thread_index_set_struct_handle(msg_struct_s *msg_struct, int field, msg_struct_s *value)
2475 msg_error_t err = MSG_SUCCESS;
2477 if (!msg_struct || !value)
2478 return MSG_ERR_NULL_POINTER;
2480 MSG_THREAD_LIST_INDEX_INFO_S *pIndex = (MSG_THREAD_LIST_INDEX_INFO_S *)msg_struct->data;
2481 msg_struct_s *pTmp = NULL;
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));
2489 err = MSG_ERR_UNKNOWN;
2497 int msg_list_condition_set_struct_handle(msg_struct_s *msg_struct, int field, msg_struct_s *value)
2499 msg_error_t err = MSG_SUCCESS;
2501 if (!msg_struct || !value)
2502 return MSG_ERR_NULL_POINTER;
2504 MSG_LIST_CONDITION_S *pCond = (MSG_LIST_CONDITION_S *)msg_struct->data;
2505 msg_struct_s *pTmp = NULL;
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));
2513 err = MSG_ERR_UNKNOWN;
2521 int msg_address_info_set_int(void *addrinfo, int field, int value)
2523 msg_error_t err = MSG_SUCCESS;
2526 return MSG_ERR_NULL_POINTER;
2528 MSG_ADDRESS_INFO_S *pAddr = (MSG_ADDRESS_INFO_S *)addrinfo;
2531 case MSG_ADDRESS_INFO_ADDRESS_TYPE_INT:
2532 pAddr->addressType = value;
2534 case MSG_ADDRESS_INFO_RECIPIENT_TYPE_INT:
2535 pAddr->recipientType = value;
2537 case MSG_ADDRESS_INFO_CONTACT_ID_INT:
2538 pAddr->contactId = value;
2541 err = MSG_ERR_UNKNOWN;
2549 int msg_mms_sendopt_set_int(void *opt_info, int field, int value)
2551 msg_error_t err = MSG_SUCCESS;
2554 return MSG_ERR_NULL_POINTER;
2556 MMS_SENDINGOPT_S *pOpt = (MMS_SENDINGOPT_S *)opt_info;
2559 case MSG_MMS_SENDOPTION_EXPIRY_TIME_INT:
2560 pOpt->expiryTime = value;
2562 case MSG_MMS_SENDOPTION_DELIVERY_TIME_INT:
2563 pOpt->deliveryTime = value;
2565 case MSG_MMS_SENDOPTION_PRIORITY_INT:
2566 pOpt->priority = value;
2569 err = MSG_ERR_UNKNOWN;
2576 int msg_reject_message_set_int(void *msg_info, int field, int value)
2578 msg_error_t err = MSG_SUCCESS;
2581 return MSG_ERR_NULL_POINTER;
2583 MSG_REJECT_MSG_INFO_S *pMsg = (MSG_REJECT_MSG_INFO_S *)msg_info;
2586 case MSG_REJECT_MESSAGE_MSGID_INT:
2587 pMsg->msgId = value;
2589 case MSG_REJECT_MESSAGE_DISPLAY_TIME_INT:
2590 pMsg->displayTime = value;
2593 err = MSG_ERR_UNKNOWN;
2600 int msg_address_info_set_str(void *addr_info, int field, const char *value, int size)
2602 msg_error_t err = MSG_SUCCESS;
2604 if (!addr_info || !value)
2605 return MSG_ERR_NULL_POINTER;
2607 MSG_ADDRESS_INFO_S *pAddr = (MSG_ADDRESS_INFO_S *)addr_info;
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);
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);
2622 err = MSG_ERR_UNKNOWN;
2629 int msg_media_info_set_str(void *media_info, int field, const char *value, int size)
2631 msg_error_t err = MSG_SUCCESS;
2633 if (!media_info || !value)
2634 return MSG_ERR_NULL_POINTER;
2636 MSG_MEDIA_INFO_S *pAddr = (MSG_MEDIA_INFO_S *)media_info;
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);
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);
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);
2656 err = MSG_ERR_UNKNOWN;
2663 int msg_reject_message_set_str(void *msg_info, int field, const char *value, int size)
2665 msg_error_t err = MSG_SUCCESS;
2667 if (!msg_info || !value)
2668 return MSG_ERR_NULL_POINTER;
2670 MSG_REJECT_MSG_INFO_S *pMsg = (MSG_REJECT_MSG_INFO_S *)msg_info;
2673 (size > MAX_MSG_TEXT_LEN)? _len = MAX_MSG_TEXT_LEN : _len = size;
2676 case MSG_REJECT_MESSAGE_MSGTEXT_STR:
2677 strncpy(pMsg->msgText, value, _len);
2680 err = MSG_ERR_UNKNOWN;
2687 int msg_mms_sendopt_set_bool(void *option, int field, bool value)
2689 msg_error_t err = MSG_SUCCESS;
2692 return MSG_ERR_NULL_POINTER;
2694 MMS_SENDINGOPT_S *pOpt = (MMS_SENDINGOPT_S *)option;
2697 case MSG_MMS_SENDOPTION_READ_REQUEST_BOOL:
2698 pOpt->bReadReq = value;
2700 case MSG_MMS_SENDOPTION_DELIVERY_CUSTOMTIME_BOOL:
2701 pOpt->bUseDeliveryCustomTime = value;
2704 err = MSG_ERR_UNKNOWN;
2711 int msg_sms_sendopt_set_bool(void *option, int field, bool value)
2713 msg_error_t err = MSG_SUCCESS;
2716 return MSG_ERR_NULL_POINTER;
2718 SMS_SENDINGOPT_S *pOpt = (SMS_SENDINGOPT_S *)option;
2721 case MSG_SMS_SENDOPT_REPLYPATH_BOOL:
2722 pOpt->bReplyPath = value;
2725 err = MSG_ERR_UNKNOWN;
2732 EXPORT_API int msg_add_push_event(msg_handle_t handle, const msg_struct_t push_event)
2734 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
2735 msg_error_t err = MSG_SUCCESS;
2737 if (handle == NULL || push_event == NULL)
2738 return MSG_ERR_INVALID_PARAMETER;
2740 MsgHandle* pHandle = (MsgHandle*)handle;
2742 msg_struct_s *pPush = (msg_struct_s *)push_event;
2743 MSG_TYPE_CHECK(pPush->type, MSG_STRUCT_PUSH_CONFIG_INFO);
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;
2755 EXPORT_API int msg_delete_push_event(msg_handle_t handle, const msg_struct_t push_event)
2757 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
2758 msg_error_t err = MSG_SUCCESS;
2760 if (handle == NULL || push_event == NULL)
2761 return MSG_ERR_INVALID_PARAMETER;
2763 MsgHandle* pHandle = (MsgHandle*)handle;
2765 msg_struct_s *pPush = (msg_struct_s *)push_event;
2766 MSG_TYPE_CHECK(pPush->type, MSG_STRUCT_PUSH_CONFIG_INFO);
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;
2778 EXPORT_API int msg_update_push_event(msg_handle_t handle, const msg_struct_t src_event, const msg_struct_t dst_event)
2780 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
2781 msg_error_t err = MSG_SUCCESS;
2783 if (handle == NULL || src_event == NULL || dst_event == NULL)
2784 return MSG_ERR_INVALID_PARAMETER;
2786 MsgHandle* pHandle = (MsgHandle*)handle;
2788 msg_struct_s *pSrc = (msg_struct_s *)src_event;
2789 MSG_TYPE_CHECK(pSrc->type, MSG_STRUCT_PUSH_CONFIG_INFO);
2791 msg_struct_s *pDst = (msg_struct_s *)dst_event;
2792 MSG_TYPE_CHECK(pDst->type, MSG_STRUCT_PUSH_CONFIG_INFO);
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;
2804 int msg_push_config_get_str(void *event_info, int field, char *value, int size)
2807 return MSG_ERR_NULL_POINTER;
2809 MSG_PUSH_EVENT_INFO_S *pEvent = (MSG_PUSH_EVENT_INFO_S *)event_info;
2812 case MSG_PUSH_CONFIG_CONTENT_TYPE_STR:
2813 strncpy(value, pEvent->contentType, size);
2815 case MSG_PUSH_CONFIG_APPLICATON_ID_STR:
2816 strncpy(value, pEvent->appId, size);
2818 case MSG_PUSH_CONFIG_PACKAGE_NAME_STR:
2819 strncpy(value, pEvent->pkgName, size);
2822 return MSG_ERR_INVALID_PARAMETER;
2828 int msg_push_config_get_bool(void *event_info, int field, bool *value)
2831 return MSG_ERR_NULL_POINTER;
2833 int ret = MSG_SUCCESS;
2835 MSG_PUSH_EVENT_INFO_S *pEvent = (MSG_PUSH_EVENT_INFO_S *)event_info;
2838 case MSG_PUSH_CONFIG_LAUNCH_BOOL:
2839 *value = pEvent->bLaunch;
2842 ret = MSG_ERR_INVALID_PARAMETER;
2849 int msg_push_config_set_str(void *event_info, int field, const char *value, int size)
2851 msg_error_t err = MSG_SUCCESS;
2853 if (!event_info || !value)
2854 return MSG_ERR_NULL_POINTER;
2856 MSG_PUSH_EVENT_INFO_S *pEvent = (MSG_PUSH_EVENT_INFO_S *)event_info;
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);
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);
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);
2873 err = MSG_ERR_UNKNOWN;
2880 int msg_push_config_set_bool(void *event, int field, bool value)
2882 msg_error_t err = MSG_SUCCESS;
2885 return MSG_ERR_NULL_POINTER;
2887 MSG_PUSH_EVENT_INFO_S *pEvent = (MSG_PUSH_EVENT_INFO_S *)event;
2890 case MSG_PUSH_CONFIG_LAUNCH_BOOL:
2891 pEvent->bLaunch = value;
2894 err = MSG_ERR_UNKNOWN;
2901 int msg_media_item_get_str(void *data, int field, char *value, int size)
2904 return MSG_ERR_NULL_POINTER;
2906 MSG_MEDIA_INFO_S *pMedia = (MSG_MEDIA_INFO_S *)data;
2909 case MSG_MEDIA_ITEM_STR:
2910 strncpy(value, pMedia->media_item, size);
2912 case MSG_MEDIA_MIME_TYPE_STR:
2913 strncpy(value, pMedia->mime_type, size);
2915 case MSG_MEDIA_THUMB_PATH_STR:
2916 strncpy(value, pMedia->thumb_path, size);
2919 return MSG_ERR_INVALID_PARAMETER;
2925 int msg_media_item_get_int(void *data, int field, int *value)
2927 if (!data || !value)
2928 return MSG_ERR_NULL_POINTER;
2930 int ret = MSG_SUCCESS;
2932 MSG_MEDIA_INFO_S *pMedia = (MSG_MEDIA_INFO_S *)data;
2935 case MSG_MEDIA_MESSAGE_ID_INT:
2936 *value = pMedia->msg_id;
2938 case MSG_MEDIA_TCS_LEVEL_INT:
2939 *value = pMedia->tcs_level;
2941 case MSG_MEDIA_MALWARE_ALLOW_INT:
2942 *value = pMedia->malware_allow;
2944 case MSG_MEDIA_THUMBNAIL_TCS_LEVEL_INT:
2945 *value = pMedia->thumb_tcs_level;
2947 case MSG_MEDIA_THUMBNAIL_MALWARE_ALLOW_INT:
2948 *value = pMedia->thumb_malware_allow;
2951 ret = MSG_ERR_INVALID_PARAMETER;
2958 EXPORT_API int msg_allow_tcs_message(msg_handle_t handle, msg_message_id_t msg_id)
2960 msg_error_t err = MSG_SUCCESS;
2962 if (handle == NULL) {
2963 return MSG_ERR_INVALID_PARAMETER;
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;