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.
18 #include <MsgException.h>
19 #include "MsgHandle.h"
22 #include "msg_private.h"
25 /*******************************************************************************
27 *******************************************************************************/
29 int msg_setting_get_int_value(msg_struct_s *msg_struct, int field, int *value)
31 int err = MSG_SUCCESS;
33 switch (msg_struct->type) {
34 case MSG_STRUCT_SETTING_SMSC_OPT:
35 err = msg_get_smsc_opt_int(msg_struct->data, field, value);
37 case MSG_STRUCT_SETTING_SMSC_INFO:
38 err = msg_get_smsc_info_int(msg_struct->data, field, value);
40 case MSG_STRUCT_SETTING_CB_OPT:
41 err = msg_get_cb_option_int(msg_struct->data, field, value);
43 case MSG_STRUCT_SETTING_CB_CHANNEL_INFO:
44 err = msg_get_cb_channel_info_int(msg_struct->data, field, value);
46 case MSG_STRUCT_SETTING_SMS_SEND_OPT:
47 err = msg_get_sms_send_opt_int(msg_struct->data, field, value);
49 case MSG_STRUCT_SETTING_MMS_SEND_OPT:
50 err = msg_get_mms_send_opt_int(msg_struct->data, field, value);
52 case MSG_STRUCT_SETTING_MMS_RECV_OPT:
53 err = msg_get_mms_recv_opt_int(msg_struct->data, field, value);
55 case MSG_STRUCT_SETTING_PUSH_MSG_OPT:
56 err = msg_get_push_msg_opt_int(msg_struct->data, field, value);
58 case MSG_STRUCT_SETTING_GENERAL_OPT:
59 err = msg_get_general_opt_int(msg_struct->data, field, value);
61 case MSG_STRUCT_SETTING_MSGSIZE_OPT:
62 err = msg_get_msgsize_opt_int(msg_struct->data, field, value);
64 case MSG_STRUCT_SETTING_VOICE_MSG_OPT:
65 err = msg_get_voice_msg_opt_int(msg_struct->data, field, value);
68 err = MSG_ERR_INVALID_PARAMETER;
75 int msg_setting_get_str_value(msg_struct_s *msg_struct, int field, char *src, int size)
77 int err = MSG_SUCCESS;
79 switch (msg_struct->type) {
80 case MSG_STRUCT_SETTING_SMSC_INFO:
81 err = msg_get_smsc_info_str(msg_struct->data, field, src, size);
83 case MSG_STRUCT_SETTING_CB_CHANNEL_INFO:
84 err = msg_get_cb_channel_info_str(msg_struct->data, field, src, size);
86 case MSG_STRUCT_SETTING_VOICE_MSG_OPT:
87 err = msg_get_voice_msg_opt_str(msg_struct->data, field, src, size);
89 case MSG_STRUCT_SETTING_GENERAL_OPT:
90 err = msg_get_general_opt_str(msg_struct->data, field, src, size);
93 err = MSG_ERR_INVALID_PARAMETER;
100 int msg_setting_get_bool_value(msg_struct_s *msg_struct, int field, bool *value)
102 int err = MSG_SUCCESS;
104 switch (msg_struct->type) {
105 case MSG_STRUCT_SETTING_CB_OPT:
106 err = msg_get_cb_option_bool(msg_struct->data, field, value);
108 case MSG_STRUCT_SETTING_CB_CHANNEL_INFO:
109 err = msg_get_cb_channel_info_bool(msg_struct->data, field, value);
111 case MSG_STRUCT_SETTING_SMS_SEND_OPT:
112 err = msg_get_sms_send_opt_bool(msg_struct->data, field, value);
114 case MSG_STRUCT_SETTING_MMS_SEND_OPT:
115 err = msg_get_mms_send_opt_bool(msg_struct->data, field, value);
117 case MSG_STRUCT_SETTING_MMS_RECV_OPT:
118 err = msg_get_mms_recv_opt_bool(msg_struct->data, field, value);
120 case MSG_STRUCT_SETTING_PUSH_MSG_OPT:
121 err = msg_get_push_msg_opt_bool(msg_struct->data, field, value);
123 case MSG_STRUCT_SETTING_GENERAL_OPT:
124 err = msg_get_general_opt_bool(msg_struct->data, field, value);
127 err = MSG_ERR_INVALID_PARAMETER;
134 int msg_setting_get_list_handle(msg_struct_s *msg_struct, int field, void **value)
136 int err = MSG_SUCCESS;
138 switch (msg_struct->type) {
139 case MSG_STRUCT_SETTING_SMSC_OPT:
140 err = msg_get_smsc_opt_list(msg_struct->data, field, value);
142 case MSG_STRUCT_SETTING_CB_OPT:
143 err = msg_get_cb_option_list(msg_struct->data, field, value);
146 err = MSG_ERR_INVALID_PARAMETER;
153 int msg_setting_set_int_value(msg_struct_s *msg_struct, int field, int value)
155 int err = MSG_SUCCESS;
157 switch (msg_struct->type) {
158 case MSG_STRUCT_SETTING_SMSC_OPT:
159 err = msg_set_smsc_opt_int(msg_struct->data, field, value);
161 case MSG_STRUCT_SETTING_SMSC_INFO:
162 err = msg_set_smsc_info_int(msg_struct->data, field, value);
164 case MSG_STRUCT_SETTING_CB_OPT:
165 err = msg_set_cb_option_int(msg_struct->data, field, value);
167 case MSG_STRUCT_SETTING_CB_CHANNEL_INFO:
168 err = msg_set_cb_channel_info_int(msg_struct->data, field, value);
170 case MSG_STRUCT_SETTING_SMS_SEND_OPT:
171 err = msg_set_sms_send_opt_int(msg_struct->data, field, value);
173 case MSG_STRUCT_SETTING_MMS_SEND_OPT:
174 err = msg_set_mms_send_opt_int(msg_struct->data, field, value);
176 case MSG_STRUCT_SETTING_MMS_RECV_OPT:
177 err = msg_set_mms_recv_opt_int(msg_struct->data, field, value);
179 case MSG_STRUCT_SETTING_PUSH_MSG_OPT:
180 err = msg_set_push_msg_opt_int(msg_struct->data, field, value);
182 case MSG_STRUCT_SETTING_GENERAL_OPT:
183 err = msg_set_general_opt_int(msg_struct->data, field, value);
185 case MSG_STRUCT_SETTING_MSGSIZE_OPT:
186 err = msg_set_msgsize_opt_int(msg_struct->data, field, value);
188 case MSG_STRUCT_SETTING_VOICE_MSG_OPT:
189 err = msg_set_voice_msg_opt_int(msg_struct->data, field, value);
192 err = MSG_ERR_INVALID_PARAMETER;
199 int msg_setting_set_str_value(msg_struct_s *msg_struct, int field, const char *value, int size)
201 int err = MSG_SUCCESS;
203 switch (msg_struct->type) {
204 case MSG_STRUCT_SETTING_SMSC_INFO:
205 err = msg_set_smsc_info_str(msg_struct->data, field, value, size);
207 case MSG_STRUCT_SETTING_CB_CHANNEL_INFO:
208 err = msg_set_cb_channel_info_str(msg_struct->data, field, value, size);
210 case MSG_STRUCT_SETTING_VOICE_MSG_OPT:
211 err = msg_set_voice_msg_opt_str(msg_struct->data, field, value, size);
213 case MSG_STRUCT_SETTING_GENERAL_OPT:
214 err = msg_set_general_opt_str(msg_struct->data, field, value, size);
217 err = MSG_ERR_INVALID_PARAMETER;
224 int msg_setting_set_bool_value(msg_struct_s *msg_struct, int field, bool value)
226 int err = MSG_SUCCESS;
228 switch (msg_struct->type) {
229 case MSG_STRUCT_SETTING_CB_OPT:
230 err = msg_set_cb_option_bool(msg_struct->data, field, value);
232 case MSG_STRUCT_SETTING_CB_CHANNEL_INFO:
233 err = msg_set_cb_channel_info_bool(msg_struct->data, field, value);
235 case MSG_STRUCT_SETTING_SMS_SEND_OPT:
236 err = msg_set_sms_send_opt_bool(msg_struct->data, field, value);
238 case MSG_STRUCT_SETTING_MMS_SEND_OPT:
239 err = msg_set_mms_send_opt_bool(msg_struct->data, field, value);
241 case MSG_STRUCT_SETTING_MMS_RECV_OPT:
242 err = msg_set_mms_recv_opt_bool(msg_struct->data, field, value);
244 case MSG_STRUCT_SETTING_PUSH_MSG_OPT:
245 err = msg_set_push_msg_opt_bool(msg_struct->data, field, value);
247 case MSG_STRUCT_SETTING_GENERAL_OPT:
248 err = msg_set_general_opt_bool(msg_struct->data, field, value);
251 err = MSG_ERR_INVALID_PARAMETER;
259 EXPORT_API int msg_get_smsc_opt(msg_handle_t handle, msg_struct_t msg_struct)
261 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
263 msg_error_t err = MSG_SUCCESS;
265 if (handle == NULL || msg_struct == NULL)
266 return MSG_ERR_INVALID_PARAMETER;
268 MsgHandle* pHandle = (MsgHandle*)handle;
271 err = pHandle->getSMSCOption(msg_struct);
272 } catch (MsgException& e) {
273 MSG_FATAL("%s", e.what());
274 return MSG_ERR_SET_READ_ERROR;
280 EXPORT_API int msg_set_smsc_opt(msg_handle_t handle, msg_struct_t msg_struct)
282 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
284 msg_error_t err = MSG_SUCCESS;
286 if (handle == NULL || msg_struct == NULL)
287 return MSG_ERR_INVALID_PARAMETER;
289 MsgHandle* pHandle = (MsgHandle*)handle;
292 err = pHandle->setSMSCOption(msg_struct);
293 } catch (MsgException& e) {
294 MSG_FATAL("%s", e.what());
295 return MSG_ERR_SET_READ_ERROR;
301 int msg_get_smsc_opt_list(void *smsc_opt, int field, void **value)
304 return MSG_ERR_NULL_POINTER;
306 MSG_SMSC_LIST_HIDDEN_S *smsc_opt_data = (MSG_SMSC_LIST_HIDDEN_S *)smsc_opt;
308 int ret = MSG_SUCCESS;
311 case MSG_SMSC_LIST_STRUCT:
312 *value = (void *)smsc_opt_data->smsc_list;
315 ret = MSG_ERR_INVALID_PARAMETER;
322 int msg_get_smsc_opt_int(void *smsc_opt, int field, int *value)
325 return MSG_ERR_NULL_POINTER;
327 int ret = MSG_SUCCESS;
329 MSG_SMSC_LIST_HIDDEN_S *smsc_opt_data = (MSG_SMSC_LIST_HIDDEN_S *)smsc_opt;
332 case MSG_SMSC_SELECTED_ID_INT:
333 *value = smsc_opt_data->selected;
335 case MSG_SMSC_LIST_SIM_INDEX_INT:
336 *value = smsc_opt_data->simIndex;
339 ret = MSG_ERR_INVALID_PARAMETER;
346 int msg_set_smsc_opt_int(void *smsc_opt, int field, int value)
349 return MSG_ERR_NULL_POINTER;
351 int ret = MSG_SUCCESS;
353 MSG_SMSC_LIST_HIDDEN_S *smsc_opt_data = (MSG_SMSC_LIST_HIDDEN_S *)smsc_opt;
356 case MSG_SMSC_SELECTED_ID_INT:
357 smsc_opt_data->selected = value;
359 case MSG_SMSC_LIST_INDEX_INT:
360 smsc_opt_data->index = value;
362 case MSG_SMSC_LIST_SIM_INDEX_INT:
363 smsc_opt_data->simIndex = value;
366 ret = MSG_ERR_INVALID_PARAMETER;
373 int msg_get_smsc_info_int(void *smsc_info, int field, int *value)
376 return MSG_ERR_NULL_POINTER;
378 int ret = MSG_SUCCESS;
380 MSG_SMSC_DATA_S *smsc_data = (MSG_SMSC_DATA_S *)smsc_info;
383 case MSG_SMSC_ADDR_TON_INT:
384 *value = smsc_data->smscAddr.ton;
386 case MSG_SMSC_ADDR_NPI_INT:
387 *value = smsc_data->smscAddr.npi;
389 case MSG_SMSC_PID_INT:
390 *value = smsc_data->pid;
392 case MSG_SMSC_VAL_PERIOD_INT:
393 *value = smsc_data->valPeriod;
396 ret = MSG_ERR_INVALID_PARAMETER;
403 int msg_set_smsc_info_int(void *smsc_info, int field, int value)
406 return MSG_ERR_NULL_POINTER;
408 int err = MSG_SUCCESS;
410 MSG_SMSC_DATA_S *smsc_data = (MSG_SMSC_DATA_S *)smsc_info;
413 case MSG_SMSC_ADDR_TON_INT:
414 smsc_data->smscAddr.ton = value;
416 case MSG_SMSC_ADDR_NPI_INT:
417 smsc_data->smscAddr.npi = value;
419 case MSG_SMSC_PID_INT:
420 smsc_data->pid = value;
422 case MSG_SMSC_VAL_PERIOD_INT:
423 smsc_data->valPeriod = value;
426 err = MSG_ERR_INVALID_PARAMETER;
433 int msg_get_smsc_info_str(void *smsc_info, int field, char *value, int size)
436 return MSG_ERR_NULL_POINTER;
438 MSG_SMSC_DATA_S *smsc_data = (MSG_SMSC_DATA_S *)smsc_info;
441 case MSG_SMSC_ADDR_STR:
442 strncpy(value, smsc_data->smscAddr.address, size);
444 case MSG_SMSC_NAME_STR:
445 strncpy(value, smsc_data->name, size);
448 return MSG_ERR_INVALID_PARAMETER;
454 int msg_set_smsc_info_str(void *smsc_info, int field, const char *val, int size)
457 return MSG_ERR_NULL_POINTER;
459 int err = MSG_SUCCESS;
461 MSG_SMSC_DATA_S *smsc_data = (MSG_SMSC_DATA_S *)smsc_info;
464 case MSG_SMSC_ADDR_STR:
465 bzero(smsc_data->smscAddr.address, sizeof(smsc_data->smscAddr.address));
466 snprintf(smsc_data->smscAddr.address, sizeof(smsc_data->smscAddr.address), "%s", val);
468 case MSG_SMSC_NAME_STR:
469 bzero(smsc_data->name, sizeof(smsc_data->name));
470 snprintf(smsc_data->name, sizeof(smsc_data->name), "%s", val);
473 err = MSG_ERR_INVALID_PARAMETER;
480 EXPORT_API int msg_get_cb_opt(msg_handle_t handle, msg_struct_t msg_struct)
482 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
484 msg_error_t err = MSG_SUCCESS;
486 if (handle == NULL || msg_struct == NULL)
487 return MSG_ERR_INVALID_PARAMETER;
489 MsgHandle* pHandle = (MsgHandle*)handle;
492 err = pHandle->getCBOption(msg_struct);
493 } catch (MsgException& e) {
494 MSG_FATAL("%s", e.what());
495 return MSG_ERR_SET_READ_ERROR;
501 EXPORT_API int msg_set_cb_opt(msg_handle_t handle, msg_struct_t msg_struct)
503 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
505 msg_error_t err = MSG_SUCCESS;
507 if (handle == NULL || msg_struct == NULL)
508 return MSG_ERR_INVALID_PARAMETER;
510 MsgHandle* pHandle = (MsgHandle*)handle;
513 err = pHandle->setCBOption(msg_struct);
514 } catch (MsgException& e) {
515 MSG_FATAL("%s", e.what());
516 return MSG_ERR_SET_READ_ERROR;
522 int msg_get_cb_option_int(void *cb_opt, int field, int *value)
525 return MSG_ERR_NULL_POINTER;
527 int ret = MSG_SUCCESS;
529 MSG_CBMSG_OPT_HIDDEN_S *cb_opt_data = (MSG_CBMSG_OPT_HIDDEN_S *)cb_opt;
532 case MSG_CB_MAX_SIM_COUNT_INT:
533 *value = cb_opt_data->maxSimCnt;
535 case MSG_CB_SIM_INDEX_INT:
536 *value = cb_opt_data->simIndex;
539 ret = MSG_ERR_INVALID_PARAMETER;
546 int msg_set_cb_option_int(void *cb_opt, int field, int value)
549 return MSG_ERR_NULL_POINTER;
551 int ret = MSG_SUCCESS;
553 MSG_CBMSG_OPT_HIDDEN_S *cb_opt_data = (MSG_CBMSG_OPT_HIDDEN_S *)cb_opt;
556 case MSG_CB_MAX_SIM_COUNT_INT:
557 cb_opt_data->maxSimCnt = value;
559 case MSG_CB_SIM_INDEX_INT:
560 cb_opt_data->simIndex = value;
563 ret = MSG_ERR_INVALID_PARAMETER;
571 int msg_get_cb_option_bool(void *cb_opt, int field, bool *value)
574 return MSG_ERR_NULL_POINTER;
576 int ret = MSG_SUCCESS;
578 MSG_CBMSG_OPT_HIDDEN_S *cb_opt_data = (MSG_CBMSG_OPT_HIDDEN_S *)cb_opt;
581 case MSG_CB_RECEIVE_BOOL:
582 *value = cb_opt_data->bReceive;
584 case MSG_CB_LANGUAGE_TYPE_ALL_BOOL:
585 *value = cb_opt_data->bLanguage[MSG_CBLANG_TYPE_ALL];
587 case MSG_CB_LANGUAGE_TYPE_ENG_BOOL:
588 *value = cb_opt_data->bLanguage[MSG_CBLANG_TYPE_ENG];
590 case MSG_CB_LANGUAGE_TYPE_GER_BOOL:
591 *value = cb_opt_data->bLanguage[MSG_CBLANG_TYPE_GER];
593 case MSG_CB_LANGUAGE_TYPE_FRE_BOOL:
594 *value = cb_opt_data->bLanguage[MSG_CBLANG_TYPE_FRE];
596 case MSG_CB_LANGUAGE_TYPE_ITA_BOOL:
597 *value = cb_opt_data->bLanguage[MSG_CBLANG_TYPE_ITA];
599 case MSG_CB_LANGUAGE_TYPE_NED_BOOL:
600 *value = cb_opt_data->bLanguage[MSG_CBLANG_TYPE_NED];
602 case MSG_CB_LANGUAGE_TYPE_SPA_BOOL:
603 *value = cb_opt_data->bLanguage[MSG_CBLANG_TYPE_SPA];
605 case MSG_CB_LANGUAGE_TYPE_POR_BOOL:
606 *value = cb_opt_data->bLanguage[MSG_CBLANG_TYPE_POR];
608 case MSG_CB_LANGUAGE_TYPE_SWE_BOOL:
609 *value = cb_opt_data->bLanguage[MSG_CBLANG_TYPE_SWE];
611 case MSG_CB_LANGUAGE_TYPE_TUR_BOOL:
612 *value = cb_opt_data->bLanguage[MSG_CBLANG_TYPE_TUR];
615 ret = MSG_ERR_INVALID_PARAMETER;
622 int msg_set_cb_option_bool(void *cb_opt, int field, bool value)
625 return MSG_ERR_NULL_POINTER;
627 int ret = MSG_SUCCESS;
629 MSG_CBMSG_OPT_HIDDEN_S *cb_opt_data = (MSG_CBMSG_OPT_HIDDEN_S *)cb_opt;
632 case MSG_CB_RECEIVE_BOOL:
633 cb_opt_data->bReceive = value;
635 case MSG_CB_LANGUAGE_TYPE_ALL_BOOL:
636 cb_opt_data->bLanguage[MSG_CBLANG_TYPE_ALL] = value;
638 case MSG_CB_LANGUAGE_TYPE_ENG_BOOL:
639 cb_opt_data->bLanguage[MSG_CBLANG_TYPE_ENG] = value;
641 case MSG_CB_LANGUAGE_TYPE_GER_BOOL:
642 cb_opt_data->bLanguage[MSG_CBLANG_TYPE_GER] = value;
644 case MSG_CB_LANGUAGE_TYPE_FRE_BOOL:
645 cb_opt_data->bLanguage[MSG_CBLANG_TYPE_FRE] = value;
647 case MSG_CB_LANGUAGE_TYPE_ITA_BOOL:
648 cb_opt_data->bLanguage[MSG_CBLANG_TYPE_ITA] = value;
650 case MSG_CB_LANGUAGE_TYPE_NED_BOOL:
651 cb_opt_data->bLanguage[MSG_CBLANG_TYPE_NED] = value;
653 case MSG_CB_LANGUAGE_TYPE_SPA_BOOL:
654 cb_opt_data->bLanguage[MSG_CBLANG_TYPE_SPA] = value;
656 case MSG_CB_LANGUAGE_TYPE_POR_BOOL:
657 cb_opt_data->bLanguage[MSG_CBLANG_TYPE_POR] = value;
659 case MSG_CB_LANGUAGE_TYPE_SWE_BOOL:
660 cb_opt_data->bLanguage[MSG_CBLANG_TYPE_SWE] = value;
662 case MSG_CB_LANGUAGE_TYPE_TUR_BOOL:
663 cb_opt_data->bLanguage[MSG_CBLANG_TYPE_TUR] = value;
666 ret = MSG_ERR_INVALID_PARAMETER;
673 int msg_get_cb_option_list(void *cb_opt, int field, void **value)
676 return MSG_ERR_NULL_POINTER;
678 MSG_CBMSG_OPT_HIDDEN_S *cb_opt_data = (MSG_CBMSG_OPT_HIDDEN_S *)cb_opt;
680 int ret = MSG_SUCCESS;
683 case MSG_CB_CHANNEL_LIST_STRUCT:
684 *value = (void *)cb_opt_data->channelData;
687 ret = MSG_ERR_INVALID_PARAMETER;
694 int msg_get_cb_channel_info_int(void *cb_ch_info, int field, int *value)
697 return MSG_ERR_NULL_POINTER;
699 int ret = MSG_SUCCESS;
701 MSG_CB_CHANNEL_INFO_S *cb_ch_data = (MSG_CB_CHANNEL_INFO_S *)cb_ch_info;
704 case MSG_CB_CHANNEL_ID_FROM_INT:
705 *value = cb_ch_data->from;
707 case MSG_CB_CHANNEL_ID_TO_INT:
708 *value = cb_ch_data->to;
711 ret = MSG_ERR_INVALID_PARAMETER;
718 int msg_set_cb_channel_info_int(void *cb_ch_info, int field, int value)
721 return MSG_ERR_NULL_POINTER;
723 int ret = MSG_SUCCESS;
725 MSG_CB_CHANNEL_INFO_S *cb_ch_data = (MSG_CB_CHANNEL_INFO_S *)cb_ch_info;
728 case MSG_CB_CHANNEL_ID_FROM_INT:
729 cb_ch_data->from = value;
731 case MSG_CB_CHANNEL_ID_TO_INT:
732 cb_ch_data->to = value;
735 ret = MSG_ERR_INVALID_PARAMETER;
742 int msg_get_cb_channel_info_bool(void *cb_ch_info, int field, bool *value)
745 return MSG_ERR_NULL_POINTER;
747 int ret = MSG_SUCCESS;
749 MSG_CB_CHANNEL_INFO_S *cb_ch_data = (MSG_CB_CHANNEL_INFO_S *)cb_ch_info;
752 case MSG_CB_CHANNEL_ACTIVATE_BOOL:
753 *value = cb_ch_data->bActivate;
756 ret = MSG_ERR_INVALID_PARAMETER;
763 int msg_set_cb_channel_info_bool(void *cb_ch_info, int field, bool value)
766 return MSG_ERR_NULL_POINTER;
768 int ret = MSG_SUCCESS;
770 MSG_CB_CHANNEL_INFO_S *cb_ch_data = (MSG_CB_CHANNEL_INFO_S *)cb_ch_info;
773 case MSG_CB_CHANNEL_ACTIVATE_BOOL:
774 cb_ch_data->bActivate = value;
777 ret = MSG_ERR_INVALID_PARAMETER;
784 int msg_get_cb_channel_info_str(void *cb_ch_info, int field, char *value, int size)
787 return MSG_ERR_NULL_POINTER;
789 MSG_CB_CHANNEL_INFO_S *cb_ch_data = (MSG_CB_CHANNEL_INFO_S *)cb_ch_info;
792 case MSG_CB_CHANNEL_NAME_STR:
793 strncpy(value, cb_ch_data->name, size);
796 return MSG_ERR_INVALID_PARAMETER;
802 int msg_set_cb_channel_info_str(void *cb_ch_info, int field, const char *val, int size)
805 return MSG_ERR_NULL_POINTER;
807 int ret = MSG_SUCCESS;
809 MSG_CB_CHANNEL_INFO_S *cb_ch_data = (MSG_CB_CHANNEL_INFO_S *)cb_ch_info;
812 case MSG_CB_CHANNEL_NAME_STR:
813 bzero(cb_ch_data->name, sizeof(cb_ch_data->name));
814 snprintf(cb_ch_data->name, sizeof(cb_ch_data->name), "%s", val);
817 ret = MSG_ERR_INVALID_PARAMETER;
824 EXPORT_API int msg_get_sms_send_opt(msg_handle_t handle, msg_struct_t msg_struct)
826 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
828 msg_error_t err = MSG_SUCCESS;
830 if (handle == NULL || msg_struct == NULL)
831 return MSG_ERR_INVALID_PARAMETER;
833 MsgHandle* pHandle = (MsgHandle*)handle;
836 err = pHandle->getSmsSendOpt(msg_struct);
837 } catch (MsgException& e) {
838 MSG_FATAL("%s", e.what());
839 return MSG_ERR_SET_READ_ERROR;
845 EXPORT_API int msg_set_sms_send_opt(msg_handle_t handle, msg_struct_t msg_struct)
847 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
849 msg_error_t err = MSG_SUCCESS;
851 if (handle == NULL || msg_struct == NULL)
852 return MSG_ERR_INVALID_PARAMETER;
854 MsgHandle* pHandle = (MsgHandle*)handle;
857 err = pHandle->setSmsSendOpt(msg_struct);
858 } catch (MsgException& e) {
859 MSG_FATAL("%s", e.what());
860 return MSG_ERR_SET_READ_ERROR;
866 int msg_get_sms_send_opt_int(void *sms_send_opt, int field, int *value)
869 return MSG_ERR_NULL_POINTER;
871 int ret = MSG_SUCCESS;
873 MSG_SMS_SENDOPT_S *send_opt = (MSG_SMS_SENDOPT_S *)sms_send_opt;
876 case MSG_SMS_SENDOPT_ENCODE_TYPE_INT:
877 *value = send_opt->dcs;
879 case MSG_SMS_SENDOPT_NETWORK_MODE_INT:
880 *value = send_opt->netMode;
882 case MSG_SMS_SENDOPT_SAVE_STORAGE_INT:
883 *value = send_opt->saveStorage;
886 ret = MSG_ERR_INVALID_PARAMETER;
893 int msg_set_sms_send_opt_int(void *sms_send_opt, int field, int value)
896 return MSG_ERR_NULL_POINTER;
898 int ret = MSG_SUCCESS;
900 MSG_SMS_SENDOPT_S *send_opt = (MSG_SMS_SENDOPT_S *)sms_send_opt;
903 case MSG_SMS_SENDOPT_ENCODE_TYPE_INT:
904 send_opt->dcs = value;
906 case MSG_SMS_SENDOPT_NETWORK_MODE_INT:
907 send_opt->netMode = value;
909 case MSG_SMS_SENDOPT_SAVE_STORAGE_INT:
910 send_opt->saveStorage = value;
913 ret = MSG_ERR_INVALID_PARAMETER;
920 int msg_get_sms_send_opt_bool(void *sms_send_opt, int field, bool *value)
923 return MSG_ERR_NULL_POINTER;
925 int ret = MSG_SUCCESS;
927 MSG_SMS_SENDOPT_S *send_opt = (MSG_SMS_SENDOPT_S *)sms_send_opt;
930 case MSG_SMS_SENDOPT_REPLY_PATH_BOOL:
931 *value = send_opt->bReplyPath;
933 case MSG_SMS_SENDOPT_DELIVERY_REPORT_BOOL:
934 *value = send_opt->bDeliveryReport;
937 ret = MSG_ERR_INVALID_PARAMETER;
944 int msg_set_sms_send_opt_bool(void *sms_send_opt, int field, bool value)
949 int ret = MSG_SUCCESS;
951 MSG_SMS_SENDOPT_S *send_opt = (MSG_SMS_SENDOPT_S *)sms_send_opt;
954 case MSG_SMS_SENDOPT_REPLY_PATH_BOOL:
955 send_opt->bReplyPath = value;
957 case MSG_SMS_SENDOPT_DELIVERY_REPORT_BOOL:
958 send_opt->bDeliveryReport = value;
961 ret = MSG_ERR_INVALID_PARAMETER;
968 EXPORT_API int msg_get_mms_send_opt(msg_handle_t handle, msg_struct_t msg_struct)
970 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_MMS_FEATURE);
972 msg_error_t err = MSG_SUCCESS;
974 if (handle == NULL || msg_struct == NULL)
975 return MSG_ERR_INVALID_PARAMETER;
977 MsgHandle* pHandle = (MsgHandle*)handle;
980 err = pHandle->getMmsSendOpt(msg_struct);
981 } catch (MsgException& e) {
982 MSG_FATAL("%s", e.what());
983 return MSG_ERR_SET_READ_ERROR;
989 EXPORT_API int msg_set_mms_send_opt(msg_handle_t handle, msg_struct_t msg_struct)
991 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_MMS_FEATURE);
993 msg_error_t err = MSG_SUCCESS;
995 if (handle == NULL || msg_struct == NULL)
996 return MSG_ERR_INVALID_PARAMETER;
998 MsgHandle* pHandle = (MsgHandle*)handle;
1001 err = pHandle->setMmsSendOpt(msg_struct);
1002 } catch (MsgException& e) {
1003 MSG_FATAL("%s", e.what());
1004 return MSG_ERR_SET_READ_ERROR;
1011 int msg_get_mms_send_opt_int(void *mms_send_opt, int field, int *value)
1014 return MSG_ERR_NULL_POINTER;
1016 int ret = MSG_SUCCESS;
1018 MSG_MMS_SENDOPT_S *send_opt = (MSG_MMS_SENDOPT_S *)mms_send_opt;
1021 case MSG_MMS_SENDOPT_CLASS_TYPE_INT:
1022 *value = send_opt->msgClass;
1024 case MSG_MMS_SENDOPT_PRIORITY_TYPE_INT:
1025 *value = send_opt->priority;
1027 case MSG_MMS_SENDOPT_EXPIRY_TIME_INT:
1028 *value = send_opt->expiryTime;
1030 case MSG_MMS_SENDOPT_DELIVERY_TIME_INT:
1031 *value = send_opt->deliveryTime;
1033 case MSG_MMS_SENDOPT_CUSTOM_DELIVERY_TIME_INT:
1034 *value = send_opt->customDeliveryTime;
1036 case MSG_MMS_SENDOPT_REPLY_CHARGING_INT:
1037 *value = send_opt->replyCharging;
1039 case MSG_MMS_SENDOPT_REPLY_CHARGING_DEADLINE_INT:
1040 *value = send_opt->replyChargingDeadline;
1042 case MSG_MMS_SENDOPT_REPLY_CHARGING_SIZE_INT:
1043 *value = send_opt->replyChargingSize;
1045 case MSG_MMS_SENDOPT_CREATION_MODE_INT:
1046 *value = send_opt->creationMode;
1049 ret = MSG_ERR_INVALID_PARAMETER;
1056 int msg_set_mms_send_opt_int(void *mms_send_opt, int field, int value)
1059 return MSG_ERR_NULL_POINTER;
1061 int ret = MSG_SUCCESS;
1063 MSG_MMS_SENDOPT_S *send_opt = (MSG_MMS_SENDOPT_S *)mms_send_opt;
1066 case MSG_MMS_SENDOPT_CLASS_TYPE_INT:
1067 send_opt->msgClass = value;
1069 case MSG_MMS_SENDOPT_PRIORITY_TYPE_INT:
1070 send_opt->priority = value;
1072 case MSG_MMS_SENDOPT_EXPIRY_TIME_INT:
1073 send_opt->expiryTime = value;
1075 case MSG_MMS_SENDOPT_DELIVERY_TIME_INT:
1076 send_opt->deliveryTime = value;
1078 case MSG_MMS_SENDOPT_CUSTOM_DELIVERY_TIME_INT:
1079 send_opt->customDeliveryTime = value;
1081 case MSG_MMS_SENDOPT_REPLY_CHARGING_INT:
1082 send_opt->replyCharging = value;
1084 case MSG_MMS_SENDOPT_REPLY_CHARGING_DEADLINE_INT:
1085 send_opt->replyChargingDeadline = value;
1087 case MSG_MMS_SENDOPT_REPLY_CHARGING_SIZE_INT:
1088 send_opt->replyChargingSize = value;
1090 case MSG_MMS_SENDOPT_CREATION_MODE_INT:
1091 send_opt->creationMode = value;
1094 ret = MSG_ERR_INVALID_PARAMETER;
1101 int msg_get_mms_send_opt_bool(void *mms_send_opt, int field, bool *value)
1104 return MSG_ERR_NULL_POINTER;
1106 int ret = MSG_SUCCESS;
1108 MSG_MMS_SENDOPT_S *send_opt = (MSG_MMS_SENDOPT_S *)mms_send_opt;
1111 case MSG_MMS_SENDOPT_SENDER_VISIBILITY_BOOL:
1112 *value = send_opt->bSenderVisibility;
1114 case MSG_MMS_SENDOPT_DELIVERY_REPORT_BOOL:
1115 *value = send_opt->bDeliveryReport;
1117 case MSG_MMS_SENDOPT_READ_REPLY_BOOL:
1118 *value = send_opt->bReadReply;
1120 case MSG_MMS_SENDOPT_KEEP_COPY_BOOL:
1121 *value = send_opt->bKeepCopy;
1123 case MSG_MMS_SENDOPT_BODY_REPLYING_BOOL:
1124 *value = send_opt->bBodyReplying;
1126 case MSG_MMS_SENDOPT_HIDE_RECIPIENTS_BOOL:
1127 *value = send_opt->bHideRecipients;
1130 ret = MSG_ERR_INVALID_PARAMETER;
1137 int msg_set_mms_send_opt_bool(void *mms_send_opt, int field, bool value)
1140 return MSG_ERR_NULL_POINTER;
1142 int ret = MSG_SUCCESS;
1144 MSG_MMS_SENDOPT_S *send_opt = (MSG_MMS_SENDOPT_S *)mms_send_opt;
1147 case MSG_MMS_SENDOPT_SENDER_VISIBILITY_BOOL:
1148 send_opt->bSenderVisibility = value;
1150 case MSG_MMS_SENDOPT_DELIVERY_REPORT_BOOL:
1151 send_opt->bDeliveryReport = value;
1153 case MSG_MMS_SENDOPT_READ_REPLY_BOOL:
1154 send_opt->bReadReply = value;
1156 case MSG_MMS_SENDOPT_KEEP_COPY_BOOL:
1157 send_opt->bKeepCopy = value;
1159 case MSG_MMS_SENDOPT_BODY_REPLYING_BOOL:
1160 send_opt->bBodyReplying = value;
1162 case MSG_MMS_SENDOPT_HIDE_RECIPIENTS_BOOL:
1163 send_opt->bHideRecipients = value;
1166 ret = MSG_ERR_INVALID_PARAMETER;
1173 EXPORT_API int msg_get_mms_recv_opt(msg_handle_t handle, msg_struct_t msg_struct)
1175 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_MMS_FEATURE);
1177 msg_error_t err = MSG_SUCCESS;
1179 if (handle == NULL || msg_struct == NULL)
1180 return MSG_ERR_INVALID_PARAMETER;
1182 MsgHandle* pHandle = (MsgHandle*)handle;
1185 err = pHandle->getMmsRecvOpt(msg_struct);
1186 } catch (MsgException& e) {
1187 MSG_FATAL("%s", e.what());
1188 return MSG_ERR_SET_READ_ERROR;
1194 EXPORT_API int msg_set_mms_recv_opt(msg_handle_t handle, msg_struct_t msg_struct)
1196 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_MMS_FEATURE);
1198 msg_error_t err = MSG_SUCCESS;
1200 if (handle == NULL || msg_struct == NULL)
1201 return MSG_ERR_INVALID_PARAMETER;
1203 MsgHandle* pHandle = (MsgHandle*)handle;
1206 err = pHandle->setMmsRecvOpt(msg_struct);
1207 } catch (MsgException& e) {
1208 MSG_FATAL("%s", e.what());
1209 return MSG_ERR_SET_READ_ERROR;
1215 int msg_get_mms_recv_opt_int(void *mms_recv_opt, int field, int *value)
1218 return MSG_ERR_NULL_POINTER;
1220 int ret = MSG_SUCCESS;
1222 MSG_MMS_RECVOPT_S *recv_opt = (MSG_MMS_RECVOPT_S *)mms_recv_opt;
1225 case MSG_MMS_RECVOPT_HOME_RETRIEVE_TYPE_INT:
1226 *value = recv_opt->homeNetwork;
1228 case MSG_MMS_RECVOPT_ABROAD_RETRIEVE_TYPE_INT:
1229 *value = recv_opt->abroadNetwork;
1231 case MSG_MMS_RECVOPT_GROUP_MESSAGE_INT:
1232 *value = recv_opt->groupMessage;
1235 ret = MSG_ERR_INVALID_PARAMETER;
1242 int msg_set_mms_recv_opt_int(void *mms_recv_opt, int field, int value)
1245 return MSG_ERR_NULL_POINTER;
1247 int ret = MSG_SUCCESS;
1249 MSG_MMS_RECVOPT_S *recv_opt = (MSG_MMS_RECVOPT_S *)mms_recv_opt;
1252 case MSG_MMS_RECVOPT_HOME_RETRIEVE_TYPE_INT:
1253 recv_opt->homeNetwork = value;
1255 case MSG_MMS_RECVOPT_ABROAD_RETRIEVE_TYPE_INT:
1256 recv_opt->abroadNetwork = value;
1258 case MSG_MMS_RECVOPT_GROUP_MESSAGE_INT:
1259 recv_opt->groupMessage = value;
1262 ret = MSG_ERR_INVALID_PARAMETER;
1269 int msg_get_mms_recv_opt_bool(void *mms_recv_opt, int field, bool *value)
1272 return MSG_ERR_NULL_POINTER;
1274 int ret = MSG_SUCCESS;
1276 MSG_MMS_RECVOPT_S *recv_opt = (MSG_MMS_RECVOPT_S *)mms_recv_opt;
1279 case MSG_MMS_RECVOPT_READ_REPORT_BOOL:
1280 *value = recv_opt->readReceipt;
1282 case MSG_MMS_RECVOPT_DELIVERY_REPORT_BOOL:
1283 *value = recv_opt->bDeliveryReceipt;
1285 case MSG_MMS_RECVOPT_REJECT_UNKNOWN_BOOL:
1286 *value = recv_opt->bRejectUnknown;
1288 case MSG_MMS_RECVOPT_REJECT_ADVERTISEMENT_BOOL:
1289 *value = recv_opt->bRejectAdvertisement;
1292 ret = MSG_ERR_INVALID_PARAMETER;
1299 int msg_set_mms_recv_opt_bool(void *mms_recv_opt, int field, bool value)
1302 return MSG_ERR_NULL_POINTER;
1304 int ret = MSG_SUCCESS;
1306 MSG_MMS_RECVOPT_S *recv_opt = (MSG_MMS_RECVOPT_S *)mms_recv_opt;
1309 case MSG_MMS_RECVOPT_READ_REPORT_BOOL:
1310 recv_opt->readReceipt = value;
1312 case MSG_MMS_RECVOPT_DELIVERY_REPORT_BOOL:
1313 recv_opt->bDeliveryReceipt = value;
1315 case MSG_MMS_RECVOPT_REJECT_UNKNOWN_BOOL:
1316 recv_opt->bRejectUnknown = value;
1318 case MSG_MMS_RECVOPT_REJECT_ADVERTISEMENT_BOOL:
1319 recv_opt->bRejectAdvertisement = value;
1322 ret = MSG_ERR_INVALID_PARAMETER;
1329 EXPORT_API int msg_get_push_msg_opt(msg_handle_t handle, msg_struct_t msg_struct)
1331 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
1332 msg_error_t err = MSG_SUCCESS;
1334 if (handle == NULL || msg_struct == NULL)
1335 return MSG_ERR_INVALID_PARAMETER;
1337 MsgHandle* pHandle = (MsgHandle*)handle;
1340 err = pHandle->getPushMsgOpt(msg_struct);
1341 } catch (MsgException& e) {
1342 MSG_FATAL("%s", e.what());
1343 return MSG_ERR_SET_READ_ERROR;
1349 EXPORT_API int msg_set_push_msg_opt(msg_handle_t handle, msg_struct_t msg_struct)
1351 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
1352 msg_error_t err = MSG_SUCCESS;
1354 if (handle == NULL || msg_struct == NULL)
1355 return MSG_ERR_INVALID_PARAMETER;
1357 MsgHandle* pHandle = (MsgHandle*)handle;
1360 err = pHandle->setPushMsgOpt(msg_struct);
1361 } catch (MsgException& e) {
1362 MSG_FATAL("%s", e.what());
1363 return MSG_ERR_SET_READ_ERROR;
1369 int msg_get_push_msg_opt_int(void *push_msg_opt, int field, int *value)
1372 return MSG_ERR_NULL_POINTER;
1374 int ret = MSG_SUCCESS;
1376 MSG_PUSHMSG_OPT_S *push_opt = (MSG_PUSHMSG_OPT_S *)push_msg_opt;
1379 case MSG_PUSHMSG_SERVICE_TYPE_INT:
1380 *value = push_opt->serviceType;
1383 ret = MSG_ERR_INVALID_PARAMETER;
1390 int msg_set_push_msg_opt_int(void *push_msg_opt, int field, int value)
1393 return MSG_ERR_NULL_POINTER;
1395 int ret = MSG_SUCCESS;
1397 MSG_PUSHMSG_OPT_S *push_opt = (MSG_PUSHMSG_OPT_S *)push_msg_opt;
1400 case MSG_PUSHMSG_SERVICE_TYPE_INT:
1401 push_opt->serviceType = value;
1404 ret = MSG_ERR_INVALID_PARAMETER;
1411 int msg_get_push_msg_opt_bool(void *push_msg_opt, int field, bool *value)
1414 return MSG_ERR_NULL_POINTER;
1416 int ret = MSG_SUCCESS;
1418 MSG_PUSHMSG_OPT_S *push_opt = (MSG_PUSHMSG_OPT_S *)push_msg_opt;
1421 case MSG_PUSHMSG_RECEIVE_BOOL:
1422 *value = push_opt->bReceive;
1425 ret = MSG_ERR_INVALID_PARAMETER;
1432 int msg_set_push_msg_opt_bool(void *push_msg_opt, int field, bool value)
1435 return MSG_ERR_NULL_POINTER;
1437 int ret = MSG_SUCCESS;
1439 MSG_PUSHMSG_OPT_S *push_opt = (MSG_PUSHMSG_OPT_S *)push_msg_opt;
1442 case MSG_PUSHMSG_RECEIVE_BOOL:
1443 push_opt->bReceive = value;
1446 ret = MSG_ERR_INVALID_PARAMETER;
1453 EXPORT_API int msg_get_voice_msg_opt(msg_handle_t handle, msg_struct_t msg_struct)
1455 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
1456 msg_error_t err = MSG_SUCCESS;
1458 if (handle == NULL || msg_struct == NULL)
1459 return MSG_ERR_INVALID_PARAMETER;
1461 MsgHandle* pHandle = (MsgHandle*)handle;
1464 err = pHandle->getVoiceMsgOpt(msg_struct);
1465 } catch (MsgException& e) {
1466 MSG_FATAL("%s", e.what());
1467 return MSG_ERR_SET_READ_ERROR;
1473 EXPORT_API int msg_set_voice_msg_opt(msg_handle_t handle, msg_struct_t msg_struct)
1475 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
1476 msg_error_t err = MSG_SUCCESS;
1478 if (handle == NULL || msg_struct == NULL)
1479 return MSG_ERR_INVALID_PARAMETER;
1481 MsgHandle* pHandle = (MsgHandle*)handle;
1484 err = pHandle->setVoiceMsgOpt(msg_struct);
1485 } catch (MsgException& e) {
1486 MSG_FATAL("%s", e.what());
1487 return MSG_ERR_SET_READ_ERROR;
1493 int msg_get_voice_msg_opt_int(void *voice_msg_opt, int field, int *value)
1496 return MSG_ERR_NULL_POINTER;
1498 int ret = MSG_SUCCESS;
1500 MSG_VOICEMAIL_OPT_S *voice_opt = (MSG_VOICEMAIL_OPT_S *)voice_msg_opt;
1503 case MSG_VOICEMSG_SIM_INDEX_INT:
1504 *value = voice_opt->simIndex;
1506 case MSG_VOICEMSG_VOICE_COUNT_INT:
1507 *value = voice_opt->voiceCnt;
1510 ret = MSG_ERR_INVALID_PARAMETER;
1517 int msg_set_voice_msg_opt_int(void *voice_msg_opt, int field, int value)
1520 return MSG_ERR_NULL_POINTER;
1522 int ret = MSG_SUCCESS;
1524 MSG_VOICEMAIL_OPT_S *voice_opt = (MSG_VOICEMAIL_OPT_S *)voice_msg_opt;
1527 case MSG_VOICEMSG_SIM_INDEX_INT:
1528 voice_opt->simIndex = value;
1531 ret = MSG_ERR_INVALID_PARAMETER;
1538 int msg_get_voice_msg_opt_str(void *voice_msg_opt, int field, char *value, int size)
1541 return MSG_ERR_NULL_POINTER;
1543 MSG_VOICEMAIL_OPT_S *voice_opt = (MSG_VOICEMAIL_OPT_S *)voice_msg_opt;
1546 case MSG_VOICEMSG_ADDRESS_STR:
1547 strncpy(value, voice_opt->mailNumber, size);
1549 case MSG_VOICEMSG_ALPHA_ID_STR:
1550 strncpy(value, voice_opt->alpahId, size);
1553 return MSG_ERR_INVALID_PARAMETER;
1559 int msg_set_voice_msg_opt_str(void *voice_msg_opt, int field, const char *val, int size)
1562 return MSG_ERR_NULL_POINTER;
1564 int ret = MSG_SUCCESS;
1566 MSG_VOICEMAIL_OPT_S *voice_opt = (MSG_VOICEMAIL_OPT_S *)voice_msg_opt;
1569 case MSG_VOICEMSG_ADDRESS_STR:
1570 bzero(voice_opt->mailNumber, sizeof(voice_opt->mailNumber));
1571 snprintf(voice_opt->mailNumber, sizeof(voice_opt->mailNumber), "%s", val);
1574 ret = MSG_ERR_INVALID_PARAMETER;
1581 EXPORT_API int msg_get_general_opt(msg_handle_t handle, msg_struct_t msg_struct)
1583 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
1584 msg_error_t err = MSG_SUCCESS;
1586 if (handle == NULL || msg_struct == NULL)
1587 return MSG_ERR_INVALID_PARAMETER;
1589 MsgHandle* pHandle = (MsgHandle*)handle;
1592 err = pHandle->getGeneralOpt(msg_struct);
1593 } catch (MsgException& e) {
1594 MSG_FATAL("%s", e.what());
1595 return MSG_ERR_SET_READ_ERROR;
1601 EXPORT_API int msg_set_general_opt(msg_handle_t handle, msg_struct_t msg_struct)
1603 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
1604 msg_error_t err = MSG_SUCCESS;
1606 if (handle == NULL || msg_struct == NULL)
1607 return MSG_ERR_INVALID_PARAMETER;
1609 MsgHandle* pHandle = (MsgHandle*)handle;
1612 err = pHandle->setGeneralOpt(msg_struct);
1613 } catch (MsgException& e) {
1614 MSG_FATAL("%s", e.what());
1615 return MSG_ERR_SET_READ_ERROR;
1621 int msg_get_general_opt_int(void *general_opt, int field, int *value)
1624 return MSG_ERR_NULL_POINTER;
1626 int ret = MSG_SUCCESS;
1628 MSG_GENERAL_OPT_S *opt = (MSG_GENERAL_OPT_S *)general_opt;
1631 case MSG_GENERAL_ALERT_TONE_INT:
1632 *value = opt->alertTone;
1634 case MSG_GENERAL_SMS_LIMIT_CNT_INT:
1635 *value = opt->smsLimitCnt;
1637 case MSG_GENERAL_MMS_LIMIT_CNT_INT:
1638 *value = opt->mmsLimitCnt;
1640 case MSG_GENERAL_RINGTONE_TYPE_INT:
1641 *value = opt->ringtoneType;
1644 ret = MSG_ERR_INVALID_PARAMETER;
1651 int msg_set_general_opt_int(void *general_opt, int field, int value)
1654 return MSG_ERR_NULL_POINTER;
1656 int ret = MSG_SUCCESS;
1658 MSG_GENERAL_OPT_S *opt = (MSG_GENERAL_OPT_S *)general_opt;
1661 case MSG_GENERAL_ALERT_TONE_INT:
1662 opt->alertTone = value;
1664 case MSG_GENERAL_SMS_LIMIT_CNT_INT:
1665 opt->smsLimitCnt = value;
1667 case MSG_GENERAL_MMS_LIMIT_CNT_INT:
1668 opt->mmsLimitCnt = value;
1670 case MSG_GENERAL_RINGTONE_TYPE_INT:
1671 opt->ringtoneType = value;
1674 ret = MSG_ERR_INVALID_PARAMETER;
1681 int msg_get_general_opt_bool(void *general_opt, int field, bool *value)
1684 return MSG_ERR_NULL_POINTER;
1686 int ret = MSG_SUCCESS;
1688 MSG_GENERAL_OPT_S *opt = (MSG_GENERAL_OPT_S *)general_opt;
1691 case MSG_GENERAL_KEEP_COPY_BOOL:
1692 *value = opt->bKeepCopy;
1694 case MSG_GENERAL_AUTO_ERASE_BOOL:
1695 *value = opt->bAutoErase;
1697 case MSG_GENERAL_BLOCK_UNKNOWN_NUMBER_BOOL:
1698 *value = opt->bBlockUnknownMsg;
1700 case MSG_GENERAL_MSG_NOTIFICATION_BOOL:
1701 *value = opt->bNotification;
1703 case MSG_GENERAL_MSG_VIBRATION_BOOL:
1704 *value = opt->bVibration;
1706 case MSG_GENERAL_MSG_PREVIEW_BOOL:
1707 *value = opt->bPreview;
1710 ret = MSG_ERR_INVALID_PARAMETER;
1717 int msg_set_general_opt_bool(void *general_opt, int field, bool value)
1720 return MSG_ERR_NULL_POINTER;
1722 int ret = MSG_SUCCESS;
1724 MSG_GENERAL_OPT_S *opt = (MSG_GENERAL_OPT_S *)general_opt;
1727 case MSG_GENERAL_KEEP_COPY_BOOL:
1728 opt->bKeepCopy = value;
1730 case MSG_GENERAL_AUTO_ERASE_BOOL:
1731 opt->bAutoErase = value;
1733 case MSG_GENERAL_BLOCK_UNKNOWN_NUMBER_BOOL:
1734 opt->bBlockUnknownMsg = value;
1736 case MSG_GENERAL_MSG_NOTIFICATION_BOOL:
1737 opt->bNotification = value;
1739 case MSG_GENERAL_MSG_VIBRATION_BOOL:
1740 opt->bVibration = value;
1742 case MSG_GENERAL_MSG_PREVIEW_BOOL:
1743 opt->bPreview = value;
1746 ret = MSG_ERR_INVALID_PARAMETER;
1753 int msg_get_general_opt_str(void *general_opt, int field, char *value, int size)
1756 return MSG_ERR_NULL_POINTER;
1758 MSG_GENERAL_OPT_S *opt = (MSG_GENERAL_OPT_S *)general_opt;
1761 case MSG_GENERAL_RINGTONE_PATH_STR:
1762 strncpy(value, opt->ringtonePath, size);
1765 return MSG_ERR_INVALID_PARAMETER;
1771 int msg_set_general_opt_str(void *general_opt, int field, const char *val, int size)
1774 return MSG_ERR_NULL_POINTER;
1776 int ret = MSG_SUCCESS;
1778 MSG_GENERAL_OPT_S *opt = (MSG_GENERAL_OPT_S *)general_opt;
1781 case MSG_GENERAL_RINGTONE_PATH_STR:
1782 bzero(opt->ringtonePath, sizeof(opt->ringtonePath));
1783 snprintf(opt->ringtonePath, sizeof(opt->ringtonePath), "%s", val);
1786 ret = MSG_ERR_INVALID_PARAMETER;
1794 EXPORT_API int msg_get_msgsize_opt(msg_handle_t handle, msg_struct_t msg_struct)
1796 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_MMS_FEATURE);
1797 msg_error_t err = MSG_SUCCESS;
1799 if (handle == NULL || msg_struct == NULL)
1800 return MSG_ERR_INVALID_PARAMETER;
1802 MsgHandle* pHandle = (MsgHandle*)handle;
1805 err = pHandle->getMsgSizeOpt(msg_struct);
1806 } catch (MsgException& e) {
1807 MSG_FATAL("%s", e.what());
1808 return MSG_ERR_SET_READ_ERROR;
1814 EXPORT_API int msg_set_msgsize_opt(msg_handle_t handle, msg_struct_t msg_struct)
1816 CHECK_MSG_SUPPORTED(MSG_TELEPHONY_MMS_FEATURE);
1817 msg_error_t err = MSG_SUCCESS;
1819 if (handle == NULL || msg_struct == NULL)
1820 return MSG_ERR_INVALID_PARAMETER;
1822 MsgHandle* pHandle = (MsgHandle*)handle;
1825 err = pHandle->setMsgSizeOpt(msg_struct);
1826 } catch (MsgException& e) {
1827 MSG_FATAL("%s", e.what());
1828 return MSG_ERR_SET_READ_ERROR;
1834 int msg_get_msgsize_opt_int(void *size_opt, int field, int *value)
1837 return MSG_ERR_NULL_POINTER;
1839 int ret = MSG_SUCCESS;
1841 MSG_MSGSIZE_OPT_S *msg_opt = (MSG_MSGSIZE_OPT_S *)size_opt;
1844 case MSG_MESSAGE_SIZE_INT:
1845 *value = msg_opt->nMsgSize;
1848 ret = MSG_ERR_INVALID_PARAMETER;
1855 int msg_set_msgsize_opt_int(void *size_opt, int field, int value)
1858 return MSG_ERR_NULL_POINTER;
1860 int ret = MSG_SUCCESS;
1862 MSG_MSGSIZE_OPT_S *msg_opt = (MSG_MSGSIZE_OPT_S *)size_opt;
1865 case MSG_MESSAGE_SIZE_INT:
1866 msg_opt->nMsgSize = value;
1869 ret = MSG_ERR_INVALID_PARAMETER;