mapi/msg_setting.cpp

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15 */
  16
  17 #include <errno.h>
  18 #include <MsgException.h>
  19 #include "MsgHandle.h"
  20 #include "MsgDebug.h"
  21
  22 #include "msg_private.h"
  23 #include "msg.h"
  24
  25 /*******************************************************************************
  26  *                                                                       SMSC                                                                  *
  27  *******************************************************************************/
  28
  29 int msg_setting_get_int_value(msg_struct_s *msg_struct, int field, int *value)
  30 {
  31         int err = MSG_SUCCESS;
  32
  33         switch (msg_struct->type) {
  34         case MSG_STRUCT_SETTING_SMSC_OPT:
  35                 err = msg_get_smsc_opt_int(msg_struct->data, field, value);
  36                 break;
  37         case MSG_STRUCT_SETTING_SMSC_INFO:
  38                 err = msg_get_smsc_info_int(msg_struct->data, field, value);
  39                 break;
  40         case MSG_STRUCT_SETTING_CB_OPT:
  41                 err = msg_get_cb_option_int(msg_struct->data, field, value);
  42                 break;
  43         case MSG_STRUCT_SETTING_CB_CHANNEL_INFO:
  44                 err = msg_get_cb_channel_info_int(msg_struct->data, field, value);
  45                 break;
  46         case MSG_STRUCT_SETTING_SMS_SEND_OPT:
  47                 err = msg_get_sms_send_opt_int(msg_struct->data, field, value);
  48                 break;
  49         case MSG_STRUCT_SETTING_MMS_SEND_OPT:
  50                 err = msg_get_mms_send_opt_int(msg_struct->data, field, value);
  51                 break;
  52         case MSG_STRUCT_SETTING_MMS_RECV_OPT:
  53                 err = msg_get_mms_recv_opt_int(msg_struct->data, field, value);
  54                 break;
  55         case MSG_STRUCT_SETTING_PUSH_MSG_OPT:
  56                 err = msg_get_push_msg_opt_int(msg_struct->data, field, value);
  57                 break;
  58         case MSG_STRUCT_SETTING_GENERAL_OPT:
  59                 err = msg_get_general_opt_int(msg_struct->data, field, value);
  60                 break;
  61         case MSG_STRUCT_SETTING_MSGSIZE_OPT:
  62                 err = msg_get_msgsize_opt_int(msg_struct->data, field, value);
  63                 break;
  64         case MSG_STRUCT_SETTING_VOICE_MSG_OPT:
  65                 err = msg_get_voice_msg_opt_int(msg_struct->data, field, value);
  66                 break;
  67         default:
  68                 err = MSG_ERR_INVALID_PARAMETER;
  69                 break;
  70         }
  71
  72         return err;
  73 }
  74
  75 int msg_setting_get_str_value(msg_struct_s *msg_struct, int field, char *src, int size)
  76 {
  77         int err = MSG_SUCCESS;
  78
  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);
  82                 break;
  83         case MSG_STRUCT_SETTING_CB_CHANNEL_INFO:
  84                 err = msg_get_cb_channel_info_str(msg_struct->data, field, src, size);
  85                 break;
  86         case MSG_STRUCT_SETTING_VOICE_MSG_OPT:
  87                 err = msg_get_voice_msg_opt_str(msg_struct->data, field, src, size);
  88                 break;
  89         case MSG_STRUCT_SETTING_GENERAL_OPT:
  90                 err = msg_get_general_opt_str(msg_struct->data, field, src, size);
  91                 break;
  92         default:
  93                 err = MSG_ERR_INVALID_PARAMETER;
  94                 break;
  95         }
  96
  97         return err;
  98 }
  99
 100 int msg_setting_get_bool_value(msg_struct_s *msg_struct, int field, bool *value)
 101 {
 102         int err = MSG_SUCCESS;
 103
 104         switch (msg_struct->type) {
 105         case MSG_STRUCT_SETTING_CB_OPT:
 106                 err = msg_get_cb_option_bool(msg_struct->data, field, value);
 107                 break;
 108         case MSG_STRUCT_SETTING_CB_CHANNEL_INFO:
 109                 err = msg_get_cb_channel_info_bool(msg_struct->data, field, value);
 110                 break;
 111         case MSG_STRUCT_SETTING_SMS_SEND_OPT:
 112                 err = msg_get_sms_send_opt_bool(msg_struct->data, field, value);
 113                 break;
 114         case MSG_STRUCT_SETTING_MMS_SEND_OPT:
 115                 err = msg_get_mms_send_opt_bool(msg_struct->data, field, value);
 116                 break;
 117         case MSG_STRUCT_SETTING_MMS_RECV_OPT:
 118                 err = msg_get_mms_recv_opt_bool(msg_struct->data, field, value);
 119                 break;
 120         case MSG_STRUCT_SETTING_PUSH_MSG_OPT:
 121                 err = msg_get_push_msg_opt_bool(msg_struct->data, field, value);
 122                 break;
 123         case MSG_STRUCT_SETTING_GENERAL_OPT:
 124                 err = msg_get_general_opt_bool(msg_struct->data, field, value);
 125                 break;
 126         default:
 127                 err = MSG_ERR_INVALID_PARAMETER;
 128                 break;
 129         }
 130
 131         return err;
 132 }
 133
 134 int msg_setting_get_list_handle(msg_struct_s *msg_struct, int field, void **value)
 135 {
 136         int err = MSG_SUCCESS;
 137
 138         switch (msg_struct->type) {
 139         case MSG_STRUCT_SETTING_SMSC_OPT:
 140                 err = msg_get_smsc_opt_list(msg_struct->data, field, value);
 141                 break;
 142         case MSG_STRUCT_SETTING_CB_OPT:
 143                 err = msg_get_cb_option_list(msg_struct->data, field, value);
 144                 break;
 145         default:
 146                 err = MSG_ERR_INVALID_PARAMETER;
 147                 break;
 148         }
 149
 150         return err;
 151 }
 152
 153 int msg_setting_set_int_value(msg_struct_s *msg_struct, int field, int value)
 154 {
 155         int err = MSG_SUCCESS;
 156
 157         switch (msg_struct->type) {
 158         case MSG_STRUCT_SETTING_SMSC_OPT:
 159                 err = msg_set_smsc_opt_int(msg_struct->data, field, value);
 160                 break;
 161         case MSG_STRUCT_SETTING_SMSC_INFO:
 162                 err = msg_set_smsc_info_int(msg_struct->data, field, value);
 163                 break;
 164         case MSG_STRUCT_SETTING_CB_OPT:
 165                 err = msg_set_cb_option_int(msg_struct->data, field, value);
 166                 break;
 167         case MSG_STRUCT_SETTING_CB_CHANNEL_INFO:
 168                 err = msg_set_cb_channel_info_int(msg_struct->data, field, value);
 169                 break;
 170         case MSG_STRUCT_SETTING_SMS_SEND_OPT:
 171                 err = msg_set_sms_send_opt_int(msg_struct->data, field, value);
 172                 break;
 173         case MSG_STRUCT_SETTING_MMS_SEND_OPT:
 174                 err = msg_set_mms_send_opt_int(msg_struct->data, field, value);
 175                 break;
 176         case MSG_STRUCT_SETTING_MMS_RECV_OPT:
 177                 err = msg_set_mms_recv_opt_int(msg_struct->data, field, value);
 178                 break;
 179         case MSG_STRUCT_SETTING_PUSH_MSG_OPT:
 180                 err = msg_set_push_msg_opt_int(msg_struct->data, field, value);
 181                 break;
 182         case MSG_STRUCT_SETTING_GENERAL_OPT:
 183                 err = msg_set_general_opt_int(msg_struct->data, field, value);
 184                 break;
 185         case MSG_STRUCT_SETTING_MSGSIZE_OPT:
 186                 err = msg_set_msgsize_opt_int(msg_struct->data, field, value);
 187                 break;
 188         case MSG_STRUCT_SETTING_VOICE_MSG_OPT:
 189                 err = msg_set_voice_msg_opt_int(msg_struct->data, field, value);
 190                 break;
 191         default:
 192                 err = MSG_ERR_INVALID_PARAMETER;
 193                 break;
 194         }
 195
 196         return err;
 197 }
 198
 199 int msg_setting_set_str_value(msg_struct_s *msg_struct, int field, const char *value, int size)
 200 {
 201         int err = MSG_SUCCESS;
 202
 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);
 206                 break;
 207         case MSG_STRUCT_SETTING_CB_CHANNEL_INFO:
 208                 err = msg_set_cb_channel_info_str(msg_struct->data, field, value, size);
 209                 break;
 210         case MSG_STRUCT_SETTING_VOICE_MSG_OPT:
 211                 err = msg_set_voice_msg_opt_str(msg_struct->data, field, value, size);
 212                 break;
 213         case MSG_STRUCT_SETTING_GENERAL_OPT:
 214                 err = msg_set_general_opt_str(msg_struct->data, field, value, size);
 215                 break;
 216         default:
 217                 err = MSG_ERR_INVALID_PARAMETER;
 218                 break;
 219         }
 220
 221         return err;
 222 }
 223
 224 int msg_setting_set_bool_value(msg_struct_s *msg_struct, int field, bool value)
 225 {
 226         int err = MSG_SUCCESS;
 227
 228         switch (msg_struct->type) {
 229         case MSG_STRUCT_SETTING_CB_OPT:
 230                 err = msg_set_cb_option_bool(msg_struct->data, field, value);
 231                 break;
 232         case MSG_STRUCT_SETTING_CB_CHANNEL_INFO:
 233                 err = msg_set_cb_channel_info_bool(msg_struct->data, field, value);
 234                 break;
 235         case MSG_STRUCT_SETTING_SMS_SEND_OPT:
 236                 err = msg_set_sms_send_opt_bool(msg_struct->data, field, value);
 237                 break;
 238         case MSG_STRUCT_SETTING_MMS_SEND_OPT:
 239                 err = msg_set_mms_send_opt_bool(msg_struct->data, field, value);
 240                 break;
 241         case MSG_STRUCT_SETTING_MMS_RECV_OPT:
 242                 err = msg_set_mms_recv_opt_bool(msg_struct->data, field, value);
 243                 break;
 244         case MSG_STRUCT_SETTING_PUSH_MSG_OPT:
 245                 err = msg_set_push_msg_opt_bool(msg_struct->data, field, value);
 246                 break;
 247         case MSG_STRUCT_SETTING_GENERAL_OPT:
 248                 err = msg_set_general_opt_bool(msg_struct->data, field, value);
 249                 break;
 250         default:
 251                 err = MSG_ERR_INVALID_PARAMETER;
 252                 break;
 253         }
 254
 255         return err;
 256 }
 257
 258
 259 EXPORT_API int msg_get_smsc_opt(msg_handle_t handle, msg_struct_t msg_struct)
 260 {
 261         CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
 262
 263         msg_error_t err = MSG_SUCCESS;
 264
 265         if (handle == NULL || msg_struct == NULL)
 266                 return MSG_ERR_INVALID_PARAMETER;
 267
 268         MsgHandle* pHandle = (MsgHandle*)handle;
 269
 270         try {
 271                 err = pHandle->getSMSCOption(msg_struct);
 272         } catch (MsgException& e) {
 273                 MSG_FATAL("%s", e.what());
 274                 return MSG_ERR_SET_READ_ERROR;
 275         }
 276
 277         return err;
 278 }
 279
 280 EXPORT_API int msg_set_smsc_opt(msg_handle_t handle, msg_struct_t msg_struct)
 281 {
 282         CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
 283
 284         msg_error_t err = MSG_SUCCESS;
 285
 286         if (handle == NULL || msg_struct == NULL)
 287                 return MSG_ERR_INVALID_PARAMETER;
 288
 289         MsgHandle* pHandle = (MsgHandle*)handle;
 290
 291         try {
 292                 err = pHandle->setSMSCOption(msg_struct);
 293         } catch (MsgException& e) {
 294                 MSG_FATAL("%s", e.what());
 295                 return MSG_ERR_SET_READ_ERROR;
 296         }
 297
 298         return err;
 299 }
 300
 301 int msg_get_smsc_opt_list(void *smsc_opt, int field, void **value)
 302 {
 303         if (!smsc_opt)
 304                 return MSG_ERR_NULL_POINTER;
 305
 306         MSG_SMSC_LIST_HIDDEN_S *smsc_opt_data = (MSG_SMSC_LIST_HIDDEN_S *)smsc_opt;
 307
 308         int ret = MSG_SUCCESS;
 309
 310         switch (field) {
 311         case MSG_SMSC_LIST_STRUCT:
 312                 *value = (void *)smsc_opt_data->smsc_list;
 313                 break;
 314         default:
 315                 ret = MSG_ERR_INVALID_PARAMETER;
 316                 break;
 317         }
 318
 319         return ret;
 320 }
 321
 322 int msg_get_smsc_opt_int(void *smsc_opt, int field, int *value)
 323 {
 324         if (!smsc_opt)
 325                 return MSG_ERR_NULL_POINTER;
 326
 327         int ret = MSG_SUCCESS;
 328
 329         MSG_SMSC_LIST_HIDDEN_S *smsc_opt_data = (MSG_SMSC_LIST_HIDDEN_S *)smsc_opt;
 330
 331         switch (field) {
 332         case MSG_SMSC_SELECTED_ID_INT:
 333                 *value = smsc_opt_data->selected;
 334                 break;
 335         case MSG_SMSC_LIST_SIM_INDEX_INT:
 336                 *value  = smsc_opt_data->simIndex;
 337                 break;
 338         default:
 339                 ret = MSG_ERR_INVALID_PARAMETER;
 340                 break;
 341         }
 342
 343         return ret;
 344 }
 345
 346 int msg_set_smsc_opt_int(void *smsc_opt, int field, int value)
 347 {
 348         if (!smsc_opt)
 349                 return MSG_ERR_NULL_POINTER;
 350
 351         int ret = MSG_SUCCESS;
 352
 353         MSG_SMSC_LIST_HIDDEN_S *smsc_opt_data = (MSG_SMSC_LIST_HIDDEN_S *)smsc_opt;
 354
 355         switch (field) {
 356         case MSG_SMSC_SELECTED_ID_INT:
 357                 smsc_opt_data->selected = value;
 358                 break;
 359         case MSG_SMSC_LIST_INDEX_INT:
 360                 smsc_opt_data->index = value;
 361                 break;
 362         case MSG_SMSC_LIST_SIM_INDEX_INT:
 363                 smsc_opt_data->simIndex = value;
 364                 break;
 365         default:
 366                 ret = MSG_ERR_INVALID_PARAMETER;
 367                 break;
 368         }
 369
 370         return ret;
 371 }
 372
 373 int msg_get_smsc_info_int(void *smsc_info, int field, int *value)
 374 {
 375         if (!smsc_info)
 376                 return MSG_ERR_NULL_POINTER;
 377
 378         int ret = MSG_SUCCESS;
 379
 380         MSG_SMSC_DATA_S *smsc_data = (MSG_SMSC_DATA_S *)smsc_info;
 381
 382         switch (field) {
 383         case MSG_SMSC_ADDR_TON_INT:
 384                 *value = smsc_data->smscAddr.ton;
 385                 break;
 386         case MSG_SMSC_ADDR_NPI_INT:
 387                 *value = smsc_data->smscAddr.npi;
 388                 break;
 389         case MSG_SMSC_PID_INT:
 390                 *value = smsc_data->pid;
 391                 break;
 392         case MSG_SMSC_VAL_PERIOD_INT:
 393                 *value = smsc_data->valPeriod;
 394                 break;
 395         default:
 396                 ret = MSG_ERR_INVALID_PARAMETER;
 397                 break;
 398         }
 399
 400         return ret;
 401 }
 402
 403 int msg_set_smsc_info_int(void *smsc_info, int field, int value)
 404 {
 405         if (!smsc_info)
 406                 return MSG_ERR_NULL_POINTER;
 407
 408         int err = MSG_SUCCESS;
 409
 410         MSG_SMSC_DATA_S *smsc_data = (MSG_SMSC_DATA_S *)smsc_info;
 411
 412         switch (field) {
 413         case MSG_SMSC_ADDR_TON_INT:
 414                 smsc_data->smscAddr.ton = value;
 415                 break;
 416         case MSG_SMSC_ADDR_NPI_INT:
 417                 smsc_data->smscAddr.npi = value;
 418                 break;
 419         case MSG_SMSC_PID_INT:
 420                 smsc_data->pid = value;
 421                 break;
 422         case MSG_SMSC_VAL_PERIOD_INT:
 423                 smsc_data->valPeriod = value;
 424                 break;
 425         default:
 426                 err = MSG_ERR_INVALID_PARAMETER;
 427                 break;
 428         }
 429
 430         return err;
 431 }
 432
 433 int msg_get_smsc_info_str(void *smsc_info, int field, char *value, int size)
 434 {
 435         if (!smsc_info)
 436                 return MSG_ERR_NULL_POINTER;
 437
 438         MSG_SMSC_DATA_S *smsc_data = (MSG_SMSC_DATA_S *)smsc_info;
 439
 440         switch (field) {
 441         case MSG_SMSC_ADDR_STR:
 442                 strncpy(value, smsc_data->smscAddr.address, size);
 443                 break;
 444         case MSG_SMSC_NAME_STR:
 445                 strncpy(value, smsc_data->name, size);
 446                 break;
 447         default:
 448                 return MSG_ERR_INVALID_PARAMETER;
 449         }
 450
 451         return MSG_SUCCESS;
 452 }
 453
 454 int msg_set_smsc_info_str(void *smsc_info, int field, const char *val, int size)
 455 {
 456         if (!smsc_info)
 457                 return MSG_ERR_NULL_POINTER;
 458
 459         int err = MSG_SUCCESS;
 460
 461         MSG_SMSC_DATA_S *smsc_data = (MSG_SMSC_DATA_S *)smsc_info;
 462
 463         switch (field) {
 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);
 467                 break;
 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);
 471                 break;
 472         default:
 473                 err = MSG_ERR_INVALID_PARAMETER;
 474                 break;
 475         }
 476
 477         return err;
 478 }
 479
 480 EXPORT_API int msg_get_cb_opt(msg_handle_t handle, msg_struct_t msg_struct)
 481 {
 482         CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
 483
 484         msg_error_t err = MSG_SUCCESS;
 485
 486         if (handle == NULL || msg_struct == NULL)
 487                 return MSG_ERR_INVALID_PARAMETER;
 488
 489         MsgHandle* pHandle = (MsgHandle*)handle;
 490
 491         try {
 492                 err = pHandle->getCBOption(msg_struct);
 493         } catch (MsgException& e) {
 494                 MSG_FATAL("%s", e.what());
 495                 return MSG_ERR_SET_READ_ERROR;
 496         }
 497
 498         return err;
 499 }
 500
 501 EXPORT_API int msg_set_cb_opt(msg_handle_t handle, msg_struct_t msg_struct)
 502 {
 503         CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
 504
 505         msg_error_t err = MSG_SUCCESS;
 506
 507         if (handle == NULL || msg_struct == NULL)
 508                 return MSG_ERR_INVALID_PARAMETER;
 509
 510         MsgHandle* pHandle = (MsgHandle*)handle;
 511
 512         try {
 513                 err = pHandle->setCBOption(msg_struct);
 514         } catch (MsgException& e) {
 515                 MSG_FATAL("%s", e.what());
 516                 return MSG_ERR_SET_READ_ERROR;
 517         }
 518
 519         return err;
 520 }
 521
 522 int msg_get_cb_option_int(void *cb_opt, int field, int *value)
 523 {
 524         if (!cb_opt)
 525                 return MSG_ERR_NULL_POINTER;
 526
 527         int ret = MSG_SUCCESS;
 528
 529         MSG_CBMSG_OPT_HIDDEN_S *cb_opt_data = (MSG_CBMSG_OPT_HIDDEN_S *)cb_opt;
 530
 531         switch (field) {
 532         case MSG_CB_MAX_SIM_COUNT_INT:
 533                 *value = cb_opt_data->maxSimCnt;
 534                 break;
 535         case MSG_CB_SIM_INDEX_INT:
 536                 *value = cb_opt_data->simIndex;
 537                 break;
 538         default:
 539                 ret = MSG_ERR_INVALID_PARAMETER;
 540                 break;
 541         }
 542
 543         return ret;
 544 }
 545
 546 int msg_set_cb_option_int(void *cb_opt, int field, int value)
 547 {
 548         if (!cb_opt)
 549                 return MSG_ERR_NULL_POINTER;
 550
 551         int ret = MSG_SUCCESS;
 552
 553         MSG_CBMSG_OPT_HIDDEN_S *cb_opt_data = (MSG_CBMSG_OPT_HIDDEN_S *)cb_opt;
 554
 555         switch (field) {
 556         case MSG_CB_MAX_SIM_COUNT_INT:
 557                 cb_opt_data->maxSimCnt = value;
 558                 break;
 559         case MSG_CB_SIM_INDEX_INT:
 560                 cb_opt_data->simIndex = value;
 561                 break;
 562         default:
 563                 ret = MSG_ERR_INVALID_PARAMETER;
 564                 break;
 565         }
 566
 567         return ret;
 568 }
 569
 570
 571 int msg_get_cb_option_bool(void *cb_opt, int field, bool *value)
 572 {
 573         if (!cb_opt)
 574                 return MSG_ERR_NULL_POINTER;
 575
 576         int ret = MSG_SUCCESS;
 577
 578         MSG_CBMSG_OPT_HIDDEN_S *cb_opt_data = (MSG_CBMSG_OPT_HIDDEN_S *)cb_opt;
 579
 580         switch (field) {
 581         case MSG_CB_RECEIVE_BOOL:
 582                 *value = cb_opt_data->bReceive;
 583                 break;
 584         case MSG_CB_LANGUAGE_TYPE_ALL_BOOL:
 585                 *value = cb_opt_data->bLanguage[MSG_CBLANG_TYPE_ALL];
 586                 break;
 587         case MSG_CB_LANGUAGE_TYPE_ENG_BOOL:
 588                 *value = cb_opt_data->bLanguage[MSG_CBLANG_TYPE_ENG];
 589                 break;
 590         case MSG_CB_LANGUAGE_TYPE_GER_BOOL:
 591                 *value = cb_opt_data->bLanguage[MSG_CBLANG_TYPE_GER];
 592                 break;
 593         case MSG_CB_LANGUAGE_TYPE_FRE_BOOL:
 594                 *value = cb_opt_data->bLanguage[MSG_CBLANG_TYPE_FRE];
 595                 break;
 596         case MSG_CB_LANGUAGE_TYPE_ITA_BOOL:
 597                 *value = cb_opt_data->bLanguage[MSG_CBLANG_TYPE_ITA];
 598                 break;
 599         case MSG_CB_LANGUAGE_TYPE_NED_BOOL:
 600                 *value = cb_opt_data->bLanguage[MSG_CBLANG_TYPE_NED];
 601                 break;
 602         case MSG_CB_LANGUAGE_TYPE_SPA_BOOL:
 603                 *value = cb_opt_data->bLanguage[MSG_CBLANG_TYPE_SPA];
 604                 break;
 605         case MSG_CB_LANGUAGE_TYPE_POR_BOOL:
 606                 *value = cb_opt_data->bLanguage[MSG_CBLANG_TYPE_POR];
 607                 break;
 608         case MSG_CB_LANGUAGE_TYPE_SWE_BOOL:
 609                 *value = cb_opt_data->bLanguage[MSG_CBLANG_TYPE_SWE];
 610                 break;
 611         case MSG_CB_LANGUAGE_TYPE_TUR_BOOL:
 612                 *value = cb_opt_data->bLanguage[MSG_CBLANG_TYPE_TUR];
 613                 break;
 614         default:
 615                 ret = MSG_ERR_INVALID_PARAMETER;
 616                 break;
 617         }
 618
 619         return ret;
 620 }
 621
 622 int msg_set_cb_option_bool(void *cb_opt, int field, bool value)
 623 {
 624         if (!cb_opt)
 625                 return MSG_ERR_NULL_POINTER;
 626
 627         int ret = MSG_SUCCESS;
 628
 629         MSG_CBMSG_OPT_HIDDEN_S *cb_opt_data = (MSG_CBMSG_OPT_HIDDEN_S *)cb_opt;
 630
 631         switch (field) {
 632         case MSG_CB_RECEIVE_BOOL:
 633                 cb_opt_data->bReceive = value;
 634                 break;
 635         case MSG_CB_LANGUAGE_TYPE_ALL_BOOL:
 636                 cb_opt_data->bLanguage[MSG_CBLANG_TYPE_ALL] = value;
 637                 break;
 638         case MSG_CB_LANGUAGE_TYPE_ENG_BOOL:
 639                 cb_opt_data->bLanguage[MSG_CBLANG_TYPE_ENG] = value;
 640                 break;
 641         case MSG_CB_LANGUAGE_TYPE_GER_BOOL:
 642                 cb_opt_data->bLanguage[MSG_CBLANG_TYPE_GER] = value;
 643                 break;
 644         case MSG_CB_LANGUAGE_TYPE_FRE_BOOL:
 645                 cb_opt_data->bLanguage[MSG_CBLANG_TYPE_FRE] = value;
 646                 break;
 647         case MSG_CB_LANGUAGE_TYPE_ITA_BOOL:
 648                 cb_opt_data->bLanguage[MSG_CBLANG_TYPE_ITA] = value;
 649                 break;
 650         case MSG_CB_LANGUAGE_TYPE_NED_BOOL:
 651                 cb_opt_data->bLanguage[MSG_CBLANG_TYPE_NED] = value;
 652                 break;
 653         case MSG_CB_LANGUAGE_TYPE_SPA_BOOL:
 654                 cb_opt_data->bLanguage[MSG_CBLANG_TYPE_SPA] = value;
 655                 break;
 656         case MSG_CB_LANGUAGE_TYPE_POR_BOOL:
 657                 cb_opt_data->bLanguage[MSG_CBLANG_TYPE_POR] = value;
 658                 break;
 659         case MSG_CB_LANGUAGE_TYPE_SWE_BOOL:
 660                 cb_opt_data->bLanguage[MSG_CBLANG_TYPE_SWE] = value;
 661                 break;
 662         case MSG_CB_LANGUAGE_TYPE_TUR_BOOL:
 663                 cb_opt_data->bLanguage[MSG_CBLANG_TYPE_TUR] = value;
 664                 break;
 665         default:
 666                 ret = MSG_ERR_INVALID_PARAMETER;
 667                 break;
 668         }
 669
 670         return ret;
 671 }
 672
 673 int msg_get_cb_option_list(void *cb_opt, int field, void **value)
 674 {
 675         if (!cb_opt)
 676                 return MSG_ERR_NULL_POINTER;
 677
 678         MSG_CBMSG_OPT_HIDDEN_S *cb_opt_data = (MSG_CBMSG_OPT_HIDDEN_S *)cb_opt;
 679
 680         int ret = MSG_SUCCESS;
 681
 682         switch (field) {
 683         case MSG_CB_CHANNEL_LIST_STRUCT:
 684                 *value = (void *)cb_opt_data->channelData;
 685                 break;
 686         default:
 687                 ret = MSG_ERR_INVALID_PARAMETER;
 688                 break;
 689         }
 690
 691         return ret;
 692 }
 693
 694 int msg_get_cb_channel_info_int(void *cb_ch_info, int field, int *value)
 695 {
 696         if (!cb_ch_info)
 697                 return MSG_ERR_NULL_POINTER;
 698
 699         int ret = MSG_SUCCESS;
 700
 701         MSG_CB_CHANNEL_INFO_S *cb_ch_data = (MSG_CB_CHANNEL_INFO_S *)cb_ch_info;
 702
 703         switch (field) {
 704         case MSG_CB_CHANNEL_ID_FROM_INT:
 705                 *value = cb_ch_data->from;
 706                 break;
 707         case MSG_CB_CHANNEL_ID_TO_INT:
 708                 *value = cb_ch_data->to;
 709                 break;
 710         default:
 711                 ret = MSG_ERR_INVALID_PARAMETER;
 712                 break;
 713         }
 714
 715         return ret;
 716 }
 717
 718 int msg_set_cb_channel_info_int(void *cb_ch_info, int field, int value)
 719 {
 720         if (!cb_ch_info)
 721                 return MSG_ERR_NULL_POINTER;
 722
 723         int ret = MSG_SUCCESS;
 724
 725         MSG_CB_CHANNEL_INFO_S *cb_ch_data = (MSG_CB_CHANNEL_INFO_S *)cb_ch_info;
 726
 727         switch (field) {
 728         case MSG_CB_CHANNEL_ID_FROM_INT:
 729                 cb_ch_data->from = value;
 730                 break;
 731         case MSG_CB_CHANNEL_ID_TO_INT:
 732                 cb_ch_data->to = value;
 733                 break;
 734         default:
 735                 ret = MSG_ERR_INVALID_PARAMETER;
 736                 break;
 737         }
 738
 739         return ret;
 740 }
 741
 742 int msg_get_cb_channel_info_bool(void *cb_ch_info, int field, bool *value)
 743 {
 744         if (!cb_ch_info)
 745                 return MSG_ERR_NULL_POINTER;
 746
 747         int ret = MSG_SUCCESS;
 748
 749         MSG_CB_CHANNEL_INFO_S *cb_ch_data = (MSG_CB_CHANNEL_INFO_S *)cb_ch_info;
 750
 751         switch (field) {
 752         case MSG_CB_CHANNEL_ACTIVATE_BOOL:
 753                 *value = cb_ch_data->bActivate;
 754                 break;
 755         default:
 756                 ret = MSG_ERR_INVALID_PARAMETER;
 757                 break;
 758         }
 759
 760         return ret;
 761 }
 762
 763 int msg_set_cb_channel_info_bool(void *cb_ch_info, int field, bool value)
 764 {
 765         if (!cb_ch_info)
 766                 return MSG_ERR_NULL_POINTER;
 767
 768         int ret = MSG_SUCCESS;
 769
 770         MSG_CB_CHANNEL_INFO_S *cb_ch_data = (MSG_CB_CHANNEL_INFO_S *)cb_ch_info;
 771
 772         switch (field) {
 773         case MSG_CB_CHANNEL_ACTIVATE_BOOL:
 774                 cb_ch_data->bActivate = value;
 775                 break;
 776         default:
 777                 ret = MSG_ERR_INVALID_PARAMETER;
 778                 break;
 779         }
 780
 781         return ret;
 782 }
 783
 784 int msg_get_cb_channel_info_str(void *cb_ch_info, int field, char *value, int size)
 785 {
 786         if (!cb_ch_info)
 787                 return MSG_ERR_NULL_POINTER;
 788
 789         MSG_CB_CHANNEL_INFO_S *cb_ch_data = (MSG_CB_CHANNEL_INFO_S *)cb_ch_info;
 790
 791         switch (field) {
 792         case MSG_CB_CHANNEL_NAME_STR:
 793                 strncpy(value, cb_ch_data->name, size);
 794                 break;
 795         default:
 796                 return MSG_ERR_INVALID_PARAMETER;
 797         }
 798
 799         return MSG_SUCCESS;
 800 }
 801
 802 int msg_set_cb_channel_info_str(void *cb_ch_info, int field, const char *val, int size)
 803 {
 804         if (!cb_ch_info)
 805                 return MSG_ERR_NULL_POINTER;
 806
 807         int ret = MSG_SUCCESS;
 808
 809         MSG_CB_CHANNEL_INFO_S *cb_ch_data = (MSG_CB_CHANNEL_INFO_S *)cb_ch_info;
 810
 811         switch (field) {
 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);
 815                 break;
 816         default:
 817                 ret = MSG_ERR_INVALID_PARAMETER;
 818                 break;
 819         }
 820
 821         return ret;
 822 }
 823
 824 EXPORT_API int msg_get_sms_send_opt(msg_handle_t handle, msg_struct_t msg_struct)
 825 {
 826         CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
 827
 828         msg_error_t err = MSG_SUCCESS;
 829
 830         if (handle == NULL || msg_struct == NULL)
 831                 return MSG_ERR_INVALID_PARAMETER;
 832
 833         MsgHandle* pHandle = (MsgHandle*)handle;
 834
 835         try {
 836                 err = pHandle->getSmsSendOpt(msg_struct);
 837         } catch (MsgException& e) {
 838                 MSG_FATAL("%s", e.what());
 839                 return MSG_ERR_SET_READ_ERROR;
 840         }
 841
 842         return err;
 843 }
 844
 845 EXPORT_API int msg_set_sms_send_opt(msg_handle_t handle, msg_struct_t msg_struct)
 846 {
 847         CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
 848
 849         msg_error_t err = MSG_SUCCESS;
 850
 851         if (handle == NULL || msg_struct == NULL)
 852                 return MSG_ERR_INVALID_PARAMETER;
 853
 854         MsgHandle* pHandle = (MsgHandle*)handle;
 855
 856         try {
 857                 err = pHandle->setSmsSendOpt(msg_struct);
 858         } catch (MsgException& e) {
 859                 MSG_FATAL("%s", e.what());
 860                 return MSG_ERR_SET_READ_ERROR;
 861         }
 862
 863         return err;
 864 }
 865
 866 int msg_get_sms_send_opt_int(void *sms_send_opt, int field, int *value)
 867 {
 868         if (!sms_send_opt)
 869                 return MSG_ERR_NULL_POINTER;
 870
 871         int ret = MSG_SUCCESS;
 872
 873         MSG_SMS_SENDOPT_S *send_opt = (MSG_SMS_SENDOPT_S *)sms_send_opt;
 874
 875         switch (field) {
 876         case MSG_SMS_SENDOPT_ENCODE_TYPE_INT:
 877                 *value = send_opt->dcs;
 878                 break;
 879         case MSG_SMS_SENDOPT_NETWORK_MODE_INT:
 880                 *value = send_opt->netMode;
 881                 break;
 882         case MSG_SMS_SENDOPT_SAVE_STORAGE_INT:
 883                 *value = send_opt->saveStorage;
 884                 break;
 885         default:
 886                 ret = MSG_ERR_INVALID_PARAMETER;
 887                 break;
 888         }
 889
 890         return ret;
 891 }
 892
 893 int msg_set_sms_send_opt_int(void *sms_send_opt, int field, int value)
 894 {
 895         if (!sms_send_opt)
 896                 return MSG_ERR_NULL_POINTER;
 897
 898         int ret = MSG_SUCCESS;
 899
 900         MSG_SMS_SENDOPT_S *send_opt = (MSG_SMS_SENDOPT_S *)sms_send_opt;
 901
 902         switch (field) {
 903         case MSG_SMS_SENDOPT_ENCODE_TYPE_INT:
 904                 send_opt->dcs = value;
 905                 break;
 906         case MSG_SMS_SENDOPT_NETWORK_MODE_INT:
 907                 send_opt->netMode = value;
 908                 break;
 909         case MSG_SMS_SENDOPT_SAVE_STORAGE_INT:
 910                 send_opt->saveStorage = value;
 911                 break;
 912         default:
 913                 ret = MSG_ERR_INVALID_PARAMETER;
 914                 break;
 915         }
 916
 917         return ret;
 918 }
 919
 920 int msg_get_sms_send_opt_bool(void *sms_send_opt, int field, bool *value)
 921 {
 922         if (!sms_send_opt)
 923                 return MSG_ERR_NULL_POINTER;
 924
 925         int ret = MSG_SUCCESS;
 926
 927         MSG_SMS_SENDOPT_S *send_opt = (MSG_SMS_SENDOPT_S *)sms_send_opt;
 928
 929         switch (field) {
 930         case MSG_SMS_SENDOPT_REPLY_PATH_BOOL:
 931                 *value = send_opt->bReplyPath;
 932                 break;
 933         case MSG_SMS_SENDOPT_DELIVERY_REPORT_BOOL:
 934                 *value = send_opt->bDeliveryReport;
 935                 break;
 936         default:
 937                 ret = MSG_ERR_INVALID_PARAMETER;
 938                 break;
 939         }
 940
 941         return ret;
 942 }
 943
 944 int msg_set_sms_send_opt_bool(void *sms_send_opt, int field, bool value)
 945 {
 946         if (!sms_send_opt)
 947                 return false;
 948
 949         int ret = MSG_SUCCESS;
 950
 951         MSG_SMS_SENDOPT_S *send_opt = (MSG_SMS_SENDOPT_S *)sms_send_opt;
 952
 953         switch (field) {
 954         case MSG_SMS_SENDOPT_REPLY_PATH_BOOL:
 955                 send_opt->bReplyPath = value;
 956                 break;
 957         case MSG_SMS_SENDOPT_DELIVERY_REPORT_BOOL:
 958                 send_opt->bDeliveryReport = value;
 959                 break;
 960         default:
 961                 ret = MSG_ERR_INVALID_PARAMETER;
 962                 break;
 963         }
 964
 965         return ret;
 966 }
 967
 968 EXPORT_API int msg_get_mms_send_opt(msg_handle_t handle, msg_struct_t msg_struct)
 969 {
 970         CHECK_MSG_SUPPORTED(MSG_TELEPHONY_MMS_FEATURE);
 971
 972         msg_error_t err = MSG_SUCCESS;
 973
 974         if (handle == NULL || msg_struct == NULL)
 975                 return MSG_ERR_INVALID_PARAMETER;
 976
 977         MsgHandle* pHandle = (MsgHandle*)handle;
 978
 979         try {
 980                 err = pHandle->getMmsSendOpt(msg_struct);
 981         } catch (MsgException& e) {
 982                 MSG_FATAL("%s", e.what());
 983                 return MSG_ERR_SET_READ_ERROR;
 984         }
 985
 986         return err;
 987 }
 988
 989 EXPORT_API int msg_set_mms_send_opt(msg_handle_t handle, msg_struct_t msg_struct)
 990 {
 991         CHECK_MSG_SUPPORTED(MSG_TELEPHONY_MMS_FEATURE);
 992
 993         msg_error_t err = MSG_SUCCESS;
 994
 995         if (handle == NULL || msg_struct == NULL)
 996                 return MSG_ERR_INVALID_PARAMETER;
 997
 998         MsgHandle* pHandle = (MsgHandle*)handle;
 999
1000         try {
1001                 err = pHandle->setMmsSendOpt(msg_struct);
1002         } catch (MsgException& e) {
1003                 MSG_FATAL("%s", e.what());
1004                 return MSG_ERR_SET_READ_ERROR;
1005         }
1006
1007         return err;
1008 }
1009
1010
1011 int msg_get_mms_send_opt_int(void *mms_send_opt, int field, int *value)
1012 {
1013         if (!mms_send_opt)
1014                 return MSG_ERR_NULL_POINTER;
1015
1016         int ret = MSG_SUCCESS;
1017
1018         MSG_MMS_SENDOPT_S *send_opt = (MSG_MMS_SENDOPT_S *)mms_send_opt;
1019
1020         switch (field) {
1021         case MSG_MMS_SENDOPT_CLASS_TYPE_INT:
1022                 *value = send_opt->msgClass;
1023                 break;
1024         case MSG_MMS_SENDOPT_PRIORITY_TYPE_INT:
1025                 *value = send_opt->priority;
1026                 break;
1027         case MSG_MMS_SENDOPT_EXPIRY_TIME_INT:
1028                 *value = send_opt->expiryTime;
1029                 break;
1030         case MSG_MMS_SENDOPT_DELIVERY_TIME_INT:
1031                 *value = send_opt->deliveryTime;
1032                 break;
1033         case MSG_MMS_SENDOPT_CUSTOM_DELIVERY_TIME_INT:
1034                 *value = send_opt->customDeliveryTime;
1035                 break;
1036         case MSG_MMS_SENDOPT_REPLY_CHARGING_INT:
1037                 *value = send_opt->replyCharging;
1038                 break;
1039         case MSG_MMS_SENDOPT_REPLY_CHARGING_DEADLINE_INT:
1040                 *value = send_opt->replyChargingDeadline;
1041                 break;
1042         case MSG_MMS_SENDOPT_REPLY_CHARGING_SIZE_INT:
1043                 *value = send_opt->replyChargingSize;
1044                 break;
1045         case MSG_MMS_SENDOPT_CREATION_MODE_INT:
1046                 *value = send_opt->creationMode;
1047                 break;
1048         default:
1049                 ret = MSG_ERR_INVALID_PARAMETER;
1050                 break;
1051         }
1052
1053         return ret;
1054 }
1055
1056 int msg_set_mms_send_opt_int(void *mms_send_opt, int field, int value)
1057 {
1058         if (!mms_send_opt)
1059                 return MSG_ERR_NULL_POINTER;
1060
1061         int ret = MSG_SUCCESS;
1062
1063         MSG_MMS_SENDOPT_S *send_opt = (MSG_MMS_SENDOPT_S *)mms_send_opt;
1064
1065         switch (field) {
1066         case MSG_MMS_SENDOPT_CLASS_TYPE_INT:
1067                 send_opt->msgClass = value;
1068                 break;
1069         case MSG_MMS_SENDOPT_PRIORITY_TYPE_INT:
1070                 send_opt->priority = value;
1071                 break;
1072         case MSG_MMS_SENDOPT_EXPIRY_TIME_INT:
1073                 send_opt->expiryTime = value;
1074                 break;
1075         case MSG_MMS_SENDOPT_DELIVERY_TIME_INT:
1076                 send_opt->deliveryTime = value;
1077                 break;
1078         case MSG_MMS_SENDOPT_CUSTOM_DELIVERY_TIME_INT:
1079                 send_opt->customDeliveryTime = value;
1080                 break;
1081         case MSG_MMS_SENDOPT_REPLY_CHARGING_INT:
1082                 send_opt->replyCharging = value;
1083                 break;
1084         case MSG_MMS_SENDOPT_REPLY_CHARGING_DEADLINE_INT:
1085                 send_opt->replyChargingDeadline = value;
1086                 break;
1087         case MSG_MMS_SENDOPT_REPLY_CHARGING_SIZE_INT:
1088                 send_opt->replyChargingSize = value;
1089                 break;
1090         case MSG_MMS_SENDOPT_CREATION_MODE_INT:
1091                 send_opt->creationMode = value;
1092                 break;
1093         default:
1094                 ret = MSG_ERR_INVALID_PARAMETER;
1095                 break;
1096         }
1097
1098         return ret;
1099 }
1100
1101 int msg_get_mms_send_opt_bool(void *mms_send_opt, int field, bool *value)
1102 {
1103         if (!mms_send_opt)
1104                 return MSG_ERR_NULL_POINTER;
1105
1106         int ret = MSG_SUCCESS;
1107
1108         MSG_MMS_SENDOPT_S *send_opt = (MSG_MMS_SENDOPT_S *)mms_send_opt;
1109
1110         switch (field) {
1111         case MSG_MMS_SENDOPT_SENDER_VISIBILITY_BOOL:
1112                 *value = send_opt->bSenderVisibility;
1113                 break;
1114         case MSG_MMS_SENDOPT_DELIVERY_REPORT_BOOL:
1115                 *value = send_opt->bDeliveryReport;
1116                 break;
1117         case MSG_MMS_SENDOPT_READ_REPLY_BOOL:
1118                 *value = send_opt->bReadReply;
1119                 break;
1120         case MSG_MMS_SENDOPT_KEEP_COPY_BOOL:
1121                 *value = send_opt->bKeepCopy;
1122                 break;
1123         case MSG_MMS_SENDOPT_BODY_REPLYING_BOOL:
1124                 *value = send_opt->bBodyReplying;
1125                 break;
1126         case MSG_MMS_SENDOPT_HIDE_RECIPIENTS_BOOL:
1127                 *value = send_opt->bHideRecipients;
1128                 break;
1129         default:
1130                 ret = MSG_ERR_INVALID_PARAMETER;
1131                 break;
1132         }
1133
1134         return ret;
1135 }
1136
1137 int msg_set_mms_send_opt_bool(void *mms_send_opt, int field, bool value)
1138 {
1139         if (!mms_send_opt)
1140                 return MSG_ERR_NULL_POINTER;
1141
1142         int ret = MSG_SUCCESS;
1143
1144         MSG_MMS_SENDOPT_S *send_opt = (MSG_MMS_SENDOPT_S *)mms_send_opt;
1145
1146         switch (field) {
1147         case MSG_MMS_SENDOPT_SENDER_VISIBILITY_BOOL:
1148                 send_opt->bSenderVisibility = value;
1149                 break;
1150         case MSG_MMS_SENDOPT_DELIVERY_REPORT_BOOL:
1151                 send_opt->bDeliveryReport = value;
1152                 break;
1153         case MSG_MMS_SENDOPT_READ_REPLY_BOOL:
1154                 send_opt->bReadReply = value;
1155                 break;
1156         case MSG_MMS_SENDOPT_KEEP_COPY_BOOL:
1157                 send_opt->bKeepCopy = value;
1158                 break;
1159         case MSG_MMS_SENDOPT_BODY_REPLYING_BOOL:
1160                 send_opt->bBodyReplying = value;
1161                 break;
1162         case MSG_MMS_SENDOPT_HIDE_RECIPIENTS_BOOL:
1163                 send_opt->bHideRecipients = value;
1164                 break;
1165         default:
1166                 ret = MSG_ERR_INVALID_PARAMETER;
1167                 break;
1168         }
1169
1170         return ret;
1171 }
1172
1173 EXPORT_API int msg_get_mms_recv_opt(msg_handle_t handle, msg_struct_t msg_struct)
1174 {
1175         CHECK_MSG_SUPPORTED(MSG_TELEPHONY_MMS_FEATURE);
1176
1177         msg_error_t err = MSG_SUCCESS;
1178
1179         if (handle == NULL || msg_struct == NULL)
1180                 return MSG_ERR_INVALID_PARAMETER;
1181
1182         MsgHandle* pHandle = (MsgHandle*)handle;
1183
1184         try {
1185                 err = pHandle->getMmsRecvOpt(msg_struct);
1186         } catch (MsgException& e) {
1187                 MSG_FATAL("%s", e.what());
1188                 return MSG_ERR_SET_READ_ERROR;
1189         }
1190
1191         return err;
1192 }
1193
1194 EXPORT_API int msg_set_mms_recv_opt(msg_handle_t handle, msg_struct_t msg_struct)
1195 {
1196         CHECK_MSG_SUPPORTED(MSG_TELEPHONY_MMS_FEATURE);
1197
1198         msg_error_t err = MSG_SUCCESS;
1199
1200         if (handle == NULL || msg_struct == NULL)
1201                 return MSG_ERR_INVALID_PARAMETER;
1202
1203         MsgHandle* pHandle = (MsgHandle*)handle;
1204
1205         try {
1206                 err = pHandle->setMmsRecvOpt(msg_struct);
1207         } catch (MsgException& e) {
1208                 MSG_FATAL("%s", e.what());
1209                 return MSG_ERR_SET_READ_ERROR;
1210         }
1211
1212         return err;
1213 }
1214
1215 int msg_get_mms_recv_opt_int(void *mms_recv_opt, int field, int *value)
1216 {
1217         if (!mms_recv_opt)
1218                 return MSG_ERR_NULL_POINTER;
1219
1220         int ret = MSG_SUCCESS;
1221
1222         MSG_MMS_RECVOPT_S *recv_opt = (MSG_MMS_RECVOPT_S *)mms_recv_opt;
1223
1224         switch (field) {
1225         case MSG_MMS_RECVOPT_HOME_RETRIEVE_TYPE_INT:
1226                 *value = recv_opt->homeNetwork;
1227                 break;
1228         case MSG_MMS_RECVOPT_ABROAD_RETRIEVE_TYPE_INT:
1229                 *value = recv_opt->abroadNetwork;
1230                 break;
1231         case MSG_MMS_RECVOPT_GROUP_MESSAGE_INT:
1232                 *value = recv_opt->groupMessage;
1233                 break;
1234         default:
1235                 ret = MSG_ERR_INVALID_PARAMETER;
1236                 break;
1237         }
1238
1239         return ret;
1240 }
1241
1242 int msg_set_mms_recv_opt_int(void *mms_recv_opt, int field, int value)
1243 {
1244         if (!mms_recv_opt)
1245                 return MSG_ERR_NULL_POINTER;
1246
1247         int ret = MSG_SUCCESS;
1248
1249         MSG_MMS_RECVOPT_S *recv_opt = (MSG_MMS_RECVOPT_S *)mms_recv_opt;
1250
1251         switch (field) {
1252         case MSG_MMS_RECVOPT_HOME_RETRIEVE_TYPE_INT:
1253                 recv_opt->homeNetwork = value;
1254                 break;
1255         case MSG_MMS_RECVOPT_ABROAD_RETRIEVE_TYPE_INT:
1256                 recv_opt->abroadNetwork = value;
1257                 break;
1258         case MSG_MMS_RECVOPT_GROUP_MESSAGE_INT:
1259                 recv_opt->groupMessage = value;
1260                 break;
1261         default:
1262                 ret = MSG_ERR_INVALID_PARAMETER;
1263                 break;
1264         }
1265
1266         return ret;
1267 }
1268
1269 int msg_get_mms_recv_opt_bool(void *mms_recv_opt, int field, bool *value)
1270 {
1271         if (!mms_recv_opt)
1272                 return MSG_ERR_NULL_POINTER;
1273
1274         int ret = MSG_SUCCESS;
1275
1276         MSG_MMS_RECVOPT_S *recv_opt = (MSG_MMS_RECVOPT_S *)mms_recv_opt;
1277
1278         switch (field) {
1279         case MSG_MMS_RECVOPT_READ_REPORT_BOOL:
1280                 *value = recv_opt->readReceipt;
1281                 break;
1282         case MSG_MMS_RECVOPT_DELIVERY_REPORT_BOOL:
1283                 *value = recv_opt->bDeliveryReceipt;
1284                 break;
1285         case MSG_MMS_RECVOPT_REJECT_UNKNOWN_BOOL:
1286                 *value = recv_opt->bRejectUnknown;
1287                 break;
1288         case MSG_MMS_RECVOPT_REJECT_ADVERTISEMENT_BOOL:
1289                 *value = recv_opt->bRejectAdvertisement;
1290                 break;
1291         default:
1292                 ret = MSG_ERR_INVALID_PARAMETER;
1293                 break;
1294         }
1295
1296         return ret;
1297 }
1298
1299 int msg_set_mms_recv_opt_bool(void *mms_recv_opt, int field, bool value)
1300 {
1301         if (!mms_recv_opt)
1302                 return MSG_ERR_NULL_POINTER;
1303
1304         int ret = MSG_SUCCESS;
1305
1306         MSG_MMS_RECVOPT_S *recv_opt = (MSG_MMS_RECVOPT_S *)mms_recv_opt;
1307
1308         switch (field) {
1309         case MSG_MMS_RECVOPT_READ_REPORT_BOOL:
1310                 recv_opt->readReceipt = value;
1311                 break;
1312         case MSG_MMS_RECVOPT_DELIVERY_REPORT_BOOL:
1313                 recv_opt->bDeliveryReceipt = value;
1314                 break;
1315         case MSG_MMS_RECVOPT_REJECT_UNKNOWN_BOOL:
1316                 recv_opt->bRejectUnknown = value;
1317                 break;
1318         case MSG_MMS_RECVOPT_REJECT_ADVERTISEMENT_BOOL:
1319                 recv_opt->bRejectAdvertisement = value;
1320                 break;
1321         default:
1322                 ret = MSG_ERR_INVALID_PARAMETER;
1323                 break;
1324         }
1325
1326         return ret;
1327 }
1328
1329 EXPORT_API int msg_get_push_msg_opt(msg_handle_t handle, msg_struct_t msg_struct)
1330 {
1331         CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
1332         msg_error_t err = MSG_SUCCESS;
1333
1334         if (handle == NULL || msg_struct == NULL)
1335                 return MSG_ERR_INVALID_PARAMETER;
1336
1337         MsgHandle* pHandle = (MsgHandle*)handle;
1338
1339         try {
1340                 err = pHandle->getPushMsgOpt(msg_struct);
1341         } catch (MsgException& e) {
1342                 MSG_FATAL("%s", e.what());
1343                 return MSG_ERR_SET_READ_ERROR;
1344         }
1345
1346         return err;
1347 }
1348
1349 EXPORT_API int msg_set_push_msg_opt(msg_handle_t handle, msg_struct_t msg_struct)
1350 {
1351         CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
1352         msg_error_t err = MSG_SUCCESS;
1353
1354         if (handle == NULL || msg_struct == NULL)
1355                 return MSG_ERR_INVALID_PARAMETER;
1356
1357         MsgHandle* pHandle = (MsgHandle*)handle;
1358
1359         try {
1360                 err = pHandle->setPushMsgOpt(msg_struct);
1361         } catch (MsgException& e) {
1362                 MSG_FATAL("%s", e.what());
1363                 return MSG_ERR_SET_READ_ERROR;
1364         }
1365
1366         return err;
1367 }
1368
1369 int msg_get_push_msg_opt_int(void *push_msg_opt, int field, int *value)
1370 {
1371         if (!push_msg_opt)
1372                 return MSG_ERR_NULL_POINTER;
1373
1374         int ret = MSG_SUCCESS;
1375
1376         MSG_PUSHMSG_OPT_S *push_opt = (MSG_PUSHMSG_OPT_S *)push_msg_opt;
1377
1378         switch (field) {
1379         case MSG_PUSHMSG_SERVICE_TYPE_INT:
1380                 *value = push_opt->serviceType;
1381                 break;
1382         default:
1383                 ret = MSG_ERR_INVALID_PARAMETER;
1384                 break;
1385         }
1386
1387         return ret;
1388 }
1389
1390 int msg_set_push_msg_opt_int(void *push_msg_opt, int field, int value)
1391 {
1392         if (!push_msg_opt)
1393                 return MSG_ERR_NULL_POINTER;
1394
1395         int ret = MSG_SUCCESS;
1396
1397         MSG_PUSHMSG_OPT_S *push_opt = (MSG_PUSHMSG_OPT_S *)push_msg_opt;
1398
1399         switch (field) {
1400         case MSG_PUSHMSG_SERVICE_TYPE_INT:
1401                 push_opt->serviceType = value;
1402                 break;
1403         default:
1404                 ret = MSG_ERR_INVALID_PARAMETER;
1405                 break;
1406         }
1407
1408         return ret;
1409 }
1410
1411 int msg_get_push_msg_opt_bool(void *push_msg_opt, int field, bool *value)
1412 {
1413         if (!push_msg_opt)
1414                 return MSG_ERR_NULL_POINTER;
1415
1416         int ret = MSG_SUCCESS;
1417
1418         MSG_PUSHMSG_OPT_S *push_opt = (MSG_PUSHMSG_OPT_S *)push_msg_opt;
1419
1420         switch (field) {
1421         case MSG_PUSHMSG_RECEIVE_BOOL:
1422                 *value = push_opt->bReceive;
1423                 break;
1424         default:
1425                 ret = MSG_ERR_INVALID_PARAMETER;
1426                 break;
1427         }
1428
1429         return ret;
1430 }
1431
1432 int msg_set_push_msg_opt_bool(void *push_msg_opt, int field, bool value)
1433 {
1434         if (!push_msg_opt)
1435                 return MSG_ERR_NULL_POINTER;
1436
1437         int ret = MSG_SUCCESS;
1438
1439         MSG_PUSHMSG_OPT_S *push_opt = (MSG_PUSHMSG_OPT_S *)push_msg_opt;
1440
1441         switch (field) {
1442         case MSG_PUSHMSG_RECEIVE_BOOL:
1443                 push_opt->bReceive = value;
1444                 break;
1445         default:
1446                 ret = MSG_ERR_INVALID_PARAMETER;
1447                 break;
1448         }
1449
1450         return ret;
1451 }
1452
1453 EXPORT_API int msg_get_voice_msg_opt(msg_handle_t handle, msg_struct_t msg_struct)
1454 {
1455         CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
1456         msg_error_t err = MSG_SUCCESS;
1457
1458         if (handle == NULL || msg_struct == NULL)
1459                 return MSG_ERR_INVALID_PARAMETER;
1460
1461         MsgHandle* pHandle = (MsgHandle*)handle;
1462
1463         try {
1464                 err = pHandle->getVoiceMsgOpt(msg_struct);
1465         } catch (MsgException& e) {
1466                 MSG_FATAL("%s", e.what());
1467                 return MSG_ERR_SET_READ_ERROR;
1468         }
1469
1470         return err;
1471 }
1472
1473 EXPORT_API int msg_set_voice_msg_opt(msg_handle_t handle, msg_struct_t msg_struct)
1474 {
1475         CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
1476         msg_error_t err = MSG_SUCCESS;
1477
1478         if (handle == NULL || msg_struct == NULL)
1479                 return MSG_ERR_INVALID_PARAMETER;
1480
1481         MsgHandle* pHandle = (MsgHandle*)handle;
1482
1483         try {
1484                 err = pHandle->setVoiceMsgOpt(msg_struct);
1485         } catch (MsgException& e) {
1486                 MSG_FATAL("%s", e.what());
1487                 return MSG_ERR_SET_READ_ERROR;
1488         }
1489
1490         return err;
1491 }
1492
1493 int msg_get_voice_msg_opt_int(void *voice_msg_opt, int field, int *value)
1494 {
1495         if (!voice_msg_opt)
1496                 return MSG_ERR_NULL_POINTER;
1497
1498         int ret = MSG_SUCCESS;
1499
1500         MSG_VOICEMAIL_OPT_S *voice_opt = (MSG_VOICEMAIL_OPT_S *)voice_msg_opt;
1501
1502         switch (field) {
1503         case MSG_VOICEMSG_SIM_INDEX_INT:
1504                 *value = voice_opt->simIndex;
1505                 break;
1506         case MSG_VOICEMSG_VOICE_COUNT_INT:
1507                 *value = voice_opt->voiceCnt;
1508                 break;
1509         default:
1510                 ret = MSG_ERR_INVALID_PARAMETER;
1511                 break;
1512         }
1513
1514         return ret;
1515 }
1516
1517 int msg_set_voice_msg_opt_int(void *voice_msg_opt, int field, int value)
1518 {
1519         if (!voice_msg_opt)
1520                 return MSG_ERR_NULL_POINTER;
1521
1522         int ret = MSG_SUCCESS;
1523
1524         MSG_VOICEMAIL_OPT_S *voice_opt = (MSG_VOICEMAIL_OPT_S *)voice_msg_opt;
1525
1526         switch (field) {
1527         case MSG_VOICEMSG_SIM_INDEX_INT:
1528                 voice_opt->simIndex = value;
1529                 break;
1530         default:
1531                 ret = MSG_ERR_INVALID_PARAMETER;
1532                 break;
1533         }
1534
1535         return ret;
1536 }
1537
1538 int msg_get_voice_msg_opt_str(void *voice_msg_opt, int field, char *value, int size)
1539 {
1540         if (!voice_msg_opt)
1541                 return MSG_ERR_NULL_POINTER;
1542
1543         MSG_VOICEMAIL_OPT_S *voice_opt = (MSG_VOICEMAIL_OPT_S *)voice_msg_opt;
1544
1545         switch (field) {
1546         case MSG_VOICEMSG_ADDRESS_STR:
1547                 strncpy(value, voice_opt->mailNumber, size);
1548                 break;
1549         case MSG_VOICEMSG_ALPHA_ID_STR:
1550                 strncpy(value, voice_opt->alpahId, size);
1551                 break;
1552         default:
1553                 return MSG_ERR_INVALID_PARAMETER;
1554         }
1555
1556         return MSG_SUCCESS;
1557 }
1558
1559 int msg_set_voice_msg_opt_str(void *voice_msg_opt, int field, const char *val, int size)
1560 {
1561         if (!voice_msg_opt)
1562                 return MSG_ERR_NULL_POINTER;
1563
1564         int ret = MSG_SUCCESS;
1565
1566         MSG_VOICEMAIL_OPT_S *voice_opt = (MSG_VOICEMAIL_OPT_S *)voice_msg_opt;
1567
1568         switch (field) {
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);
1572                 break;
1573         default:
1574                 ret = MSG_ERR_INVALID_PARAMETER;
1575                 break;
1576         }
1577
1578         return ret;
1579 }
1580
1581 EXPORT_API int msg_get_general_opt(msg_handle_t handle, msg_struct_t msg_struct)
1582 {
1583         CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
1584         msg_error_t err = MSG_SUCCESS;
1585
1586         if (handle == NULL || msg_struct == NULL)
1587                 return MSG_ERR_INVALID_PARAMETER;
1588
1589         MsgHandle* pHandle = (MsgHandle*)handle;
1590
1591         try {
1592                 err = pHandle->getGeneralOpt(msg_struct);
1593         } catch (MsgException& e) {
1594                 MSG_FATAL("%s", e.what());
1595                 return MSG_ERR_SET_READ_ERROR;
1596         }
1597
1598         return err;
1599 }
1600
1601 EXPORT_API int msg_set_general_opt(msg_handle_t handle, msg_struct_t msg_struct)
1602 {
1603         CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
1604         msg_error_t err = MSG_SUCCESS;
1605
1606         if (handle == NULL || msg_struct == NULL)
1607                 return MSG_ERR_INVALID_PARAMETER;
1608
1609         MsgHandle* pHandle = (MsgHandle*)handle;
1610
1611         try {
1612                 err = pHandle->setGeneralOpt(msg_struct);
1613         } catch (MsgException& e) {
1614                 MSG_FATAL("%s", e.what());
1615                 return MSG_ERR_SET_READ_ERROR;
1616         }
1617
1618         return err;
1619 }
1620
1621 int msg_get_general_opt_int(void *general_opt, int field, int *value)
1622 {
1623         if (!general_opt)
1624                 return MSG_ERR_NULL_POINTER;
1625
1626         int ret = MSG_SUCCESS;
1627
1628         MSG_GENERAL_OPT_S *opt = (MSG_GENERAL_OPT_S *)general_opt;
1629
1630         switch (field) {
1631         case MSG_GENERAL_ALERT_TONE_INT:
1632                 *value = opt->alertTone;
1633                 break;
1634         case MSG_GENERAL_SMS_LIMIT_CNT_INT:
1635                 *value = opt->smsLimitCnt;
1636                 break;
1637         case MSG_GENERAL_MMS_LIMIT_CNT_INT:
1638                 *value = opt->mmsLimitCnt;
1639                 break;
1640         case MSG_GENERAL_RINGTONE_TYPE_INT:
1641                 *value = opt->ringtoneType;
1642                 break;
1643         default:
1644                 ret = MSG_ERR_INVALID_PARAMETER;
1645                 break;
1646         }
1647
1648         return ret;
1649 }
1650
1651 int msg_set_general_opt_int(void *general_opt, int field, int value)
1652 {
1653         if (!general_opt)
1654                 return MSG_ERR_NULL_POINTER;
1655
1656         int ret = MSG_SUCCESS;
1657
1658         MSG_GENERAL_OPT_S *opt = (MSG_GENERAL_OPT_S *)general_opt;
1659
1660         switch (field) {
1661         case MSG_GENERAL_ALERT_TONE_INT:
1662                 opt->alertTone = value;
1663                 break;
1664         case MSG_GENERAL_SMS_LIMIT_CNT_INT:
1665                 opt->smsLimitCnt = value;
1666                 break;
1667         case MSG_GENERAL_MMS_LIMIT_CNT_INT:
1668                 opt->mmsLimitCnt = value;
1669                 break;
1670         case MSG_GENERAL_RINGTONE_TYPE_INT:
1671                 opt->ringtoneType = value;
1672                 break;
1673         default:
1674                 ret = MSG_ERR_INVALID_PARAMETER;
1675                 break;
1676         }
1677
1678         return ret;
1679 }
1680
1681 int msg_get_general_opt_bool(void *general_opt, int field, bool *value)
1682 {
1683         if (!general_opt)
1684                 return MSG_ERR_NULL_POINTER;
1685
1686         int ret = MSG_SUCCESS;
1687
1688         MSG_GENERAL_OPT_S *opt = (MSG_GENERAL_OPT_S *)general_opt;
1689
1690         switch (field) {
1691         case MSG_GENERAL_KEEP_COPY_BOOL:
1692                 *value = opt->bKeepCopy;
1693                 break;
1694         case MSG_GENERAL_AUTO_ERASE_BOOL:
1695                 *value = opt->bAutoErase;
1696                 break;
1697         case MSG_GENERAL_BLOCK_UNKNOWN_NUMBER_BOOL:
1698                 *value = opt->bBlockUnknownMsg;
1699                 break;
1700         case MSG_GENERAL_MSG_NOTIFICATION_BOOL:
1701                 *value = opt->bNotification;
1702                 break;
1703         case MSG_GENERAL_MSG_VIBRATION_BOOL:
1704                 *value = opt->bVibration;
1705                 break;
1706         case MSG_GENERAL_MSG_PREVIEW_BOOL:
1707                 *value = opt->bPreview;
1708                 break;
1709         default:
1710                 ret = MSG_ERR_INVALID_PARAMETER;
1711                 break;
1712         }
1713
1714         return ret;
1715 }
1716
1717 int msg_set_general_opt_bool(void *general_opt, int field, bool value)
1718 {
1719         if (!general_opt)
1720                 return MSG_ERR_NULL_POINTER;
1721
1722         int ret = MSG_SUCCESS;
1723
1724         MSG_GENERAL_OPT_S *opt = (MSG_GENERAL_OPT_S *)general_opt;
1725
1726         switch (field) {
1727         case MSG_GENERAL_KEEP_COPY_BOOL:
1728                 opt->bKeepCopy = value;
1729                 break;
1730         case MSG_GENERAL_AUTO_ERASE_BOOL:
1731                 opt->bAutoErase = value;
1732                 break;
1733         case MSG_GENERAL_BLOCK_UNKNOWN_NUMBER_BOOL:
1734                 opt->bBlockUnknownMsg = value;
1735                 break;
1736         case MSG_GENERAL_MSG_NOTIFICATION_BOOL:
1737                 opt->bNotification = value;
1738                 break;
1739         case MSG_GENERAL_MSG_VIBRATION_BOOL:
1740                 opt->bVibration = value;
1741                 break;
1742         case MSG_GENERAL_MSG_PREVIEW_BOOL:
1743                 opt->bPreview = value;
1744                 break;
1745         default:
1746                 ret = MSG_ERR_INVALID_PARAMETER;
1747                 break;
1748         }
1749
1750         return ret;
1751 }
1752
1753 int msg_get_general_opt_str(void *general_opt, int field, char *value, int size)
1754 {
1755         if (!general_opt)
1756                 return MSG_ERR_NULL_POINTER;
1757
1758         MSG_GENERAL_OPT_S *opt = (MSG_GENERAL_OPT_S *)general_opt;
1759
1760         switch (field) {
1761         case MSG_GENERAL_RINGTONE_PATH_STR:
1762                 strncpy(value, opt->ringtonePath, size);
1763                 break;
1764         default:
1765                 return MSG_ERR_INVALID_PARAMETER;
1766         }
1767
1768         return MSG_SUCCESS;
1769 }
1770
1771 int msg_set_general_opt_str(void *general_opt, int field, const char *val, int size)
1772 {
1773         if (!general_opt)
1774                 return MSG_ERR_NULL_POINTER;
1775
1776         int ret = MSG_SUCCESS;
1777
1778         MSG_GENERAL_OPT_S *opt = (MSG_GENERAL_OPT_S *)general_opt;
1779
1780         switch (field) {
1781         case MSG_GENERAL_RINGTONE_PATH_STR:
1782                 bzero(opt->ringtonePath, sizeof(opt->ringtonePath));
1783                 snprintf(opt->ringtonePath, sizeof(opt->ringtonePath), "%s", val);
1784                 break;
1785         default:
1786                 ret = MSG_ERR_INVALID_PARAMETER;
1787                 break;
1788         }
1789
1790         return ret;
1791 }
1792
1793
1794 EXPORT_API int msg_get_msgsize_opt(msg_handle_t handle, msg_struct_t msg_struct)
1795 {
1796         CHECK_MSG_SUPPORTED(MSG_TELEPHONY_MMS_FEATURE);
1797         msg_error_t err = MSG_SUCCESS;
1798
1799         if (handle == NULL || msg_struct == NULL)
1800                 return MSG_ERR_INVALID_PARAMETER;
1801
1802         MsgHandle* pHandle = (MsgHandle*)handle;
1803
1804         try {
1805                 err = pHandle->getMsgSizeOpt(msg_struct);
1806         } catch (MsgException& e) {
1807                 MSG_FATAL("%s", e.what());
1808                 return MSG_ERR_SET_READ_ERROR;
1809         }
1810
1811         return err;
1812 }
1813
1814 EXPORT_API int msg_set_msgsize_opt(msg_handle_t handle, msg_struct_t msg_struct)
1815 {
1816         CHECK_MSG_SUPPORTED(MSG_TELEPHONY_MMS_FEATURE);
1817         msg_error_t err = MSG_SUCCESS;
1818
1819         if (handle == NULL || msg_struct == NULL)
1820                 return MSG_ERR_INVALID_PARAMETER;
1821
1822         MsgHandle* pHandle = (MsgHandle*)handle;
1823
1824         try {
1825                 err = pHandle->setMsgSizeOpt(msg_struct);
1826         } catch (MsgException& e) {
1827                 MSG_FATAL("%s", e.what());
1828                 return MSG_ERR_SET_READ_ERROR;
1829         }
1830
1831         return err;
1832 }
1833
1834 int msg_get_msgsize_opt_int(void *size_opt, int field, int *value)
1835 {
1836         if (!size_opt)
1837                 return MSG_ERR_NULL_POINTER;
1838
1839         int ret = MSG_SUCCESS;
1840
1841         MSG_MSGSIZE_OPT_S *msg_opt = (MSG_MSGSIZE_OPT_S *)size_opt;
1842
1843         switch (field) {
1844         case MSG_MESSAGE_SIZE_INT:
1845                 *value = msg_opt->nMsgSize;
1846                 break;
1847         default:
1848                 ret = MSG_ERR_INVALID_PARAMETER;
1849                 break;
1850         }
1851
1852         return ret;
1853 }
1854
1855 int msg_set_msgsize_opt_int(void *size_opt, int field, int value)
1856 {
1857         if (!size_opt)
1858                 return MSG_ERR_NULL_POINTER;
1859
1860         int ret = MSG_SUCCESS;
1861
1862         MSG_MSGSIZE_OPT_S *msg_opt = (MSG_MSGSIZE_OPT_S *)size_opt;
1863
1864         switch (field) {
1865         case MSG_MESSAGE_SIZE_INT:
1866                 msg_opt->nMsgSize = value;
1867                 break;
1868         default:
1869                 ret = MSG_ERR_INVALID_PARAMETER;
1870                 break;
1871         }
1872
1873         return ret;
1874 }