plugin/sms_plugin/SmsPluginSetting.cpp

   1 /*
   2 *
   3 * Copyright (c) 2000-2012 Samsung Electronics Co., Ltd. All Rights Reserved.
   4 *
   5 * This file is part of msg-service.
   6 *
   7 * Contact: Jaeyun Jeong <jyjeong@samsung.com>
   8 *          Sangkoo Kim <sangkoo.kim@samsung.com>
   9 *          Seunghwan Lee <sh.cat.lee@samsung.com>
  10 *          SoonMin Jung <sm0415.jung@samsung.com>
  11 *          Jae-Young Lee <jy4710.lee@samsung.com>
  12 *          KeeBum Kim <keebum.kim@samsung.com>
  13 *
  14 * PROPRIETARY/CONFIDENTIAL
  15 *
  16 * This software is the confidential and proprietary information of
  17 * SAMSUNG ELECTRONICS ("Confidential Information"). You shall not
  18 * disclose such Confidential Information and shall use it only in
  19 * accordance with the terms of the license agreement you entered
  20 * into with SAMSUNG ELECTRONICS.
  21 *
  22 * SAMSUNG make no representations or warranties about the suitability
  23 * of the software, either express or implied, including but not limited
  24 * to the implied warranties of merchantability, fitness for a particular
  25 * purpose, or non-infringement. SAMSUNG shall not be liable for any
  26 * damages suffered by licensee as a result of using, modifying or
  27 * distributing this software or its derivatives.
  28 *
  29 */
  30
  31 #include <errno.h>
  32
  33 #include "MsgDebug.h"
  34 #include "MsgException.h"
  35 #include "MsgGconfWrapper.h"
  36 #include "SmsPluginParamCodec.h"
  37 #include "SmsPluginSetting.h"
  38
  39
  40 extern "C"
  41 {
  42 #ifndef _TAPI_NETTEXT_H_
  43         #include "ITapiNetText.h"
  44         #include "ITapiSim.h"
  45 #endif
  46 }
  47
  48
  49 /*==================================================================================================
  50                                      IMPLEMENTATION OF SmsPluginSetting - Member Functions
  51 ==================================================================================================*/
  52 SmsPluginSetting* SmsPluginSetting::pInstance = NULL;
  53
  54
  55 SmsPluginSetting::SmsPluginSetting()
  56 {
  57         // Initialize member variables
  58         memset(&smscData, 0x00, sizeof(MSG_SMSC_DATA_S));
  59         memset(&cbOpt, 0x00, sizeof(MSG_CBMSG_OPT_S));
  60
  61         bTapiResult = false;
  62         paramCnt = 0;
  63         selectedParam = 0;
  64 }
  65
  66
  67 SmsPluginSetting::~SmsPluginSetting()
  68 {
  69
  70
  71 }
  72
  73
  74 SmsPluginSetting* SmsPluginSetting::instance()
  75 {
  76         if (!pInstance)
  77                 pInstance = new SmsPluginSetting();
  78
  79         return pInstance;
  80 }
  81
  82
  83 void SmsPluginSetting::initConfigData(MSG_SIM_STATUS_T SimStatus)
  84 {
  85         MSG_BEGIN();
  86
  87         MSG_ERROR_T     err = MSG_SUCCESS;
  88
  89         // Init SMS Parameter
  90         int paramCnt = 0;
  91         int failCnt = 0;
  92
  93         paramCnt = getParamCount();
  94
  95         MSG_DEBUG("Parameter Count [%d]", paramCnt);
  96
  97         MSG_SMSC_DATA_S tmpSmscData = {};
  98         MSG_SMSC_LIST_S tmpSmscList = {};
  99
 100         for (int index = 0; index < paramCnt; index++)
 101         {
 102                 if (getParam(index, &tmpSmscData) == false)
 103                 {
 104                         failCnt++;
 105                         continue;
 106                 }
 107
 108                 memcpy(&(tmpSmscList.smscData[index]), &tmpSmscData, sizeof(MSG_SMSC_DATA_S));
 109
 110                 MSG_DEBUG("pid[%d]", tmpSmscList.smscData[index].pid);
 111                 MSG_DEBUG("val_period[%d]", tmpSmscList.smscData[index].valPeriod);
 112                 MSG_DEBUG("name[%s]", tmpSmscList.smscData[index].name);
 113
 114                 MSG_DEBUG("ton[%d]", tmpSmscList.smscData[index].smscAddr.ton);
 115                 MSG_DEBUG("npi[%d]", tmpSmscList.smscData[index].smscAddr.npi);
 116                 MSG_DEBUG("address[%s]", tmpSmscList.smscData[index].smscAddr.address);
 117         }
 118
 119         tmpSmscList.totalCnt = (paramCnt - failCnt);
 120         tmpSmscList.selected = selectedParam;
 121
 122         if (paramCnt > 0)
 123         {
 124                 err = addSMSCList(&tmpSmscList);
 125
 126                 if (err == MSG_SUCCESS)
 127                 {
 128                         MSG_DEBUG("########  Add SMSC List Success !!! #######");
 129                 }
 130                 else
 131                 {
 132                         MSG_DEBUG("########  Add SMSC List Fail !!! return : %d #######", err);
 133                 }
 134         }
 135
 136         // Init CB Config
 137         if (SimStatus == MSG_SIM_STATUS_CHANGED)
 138         {
 139                 MSG_DEBUG("simStatus == MSG_SIM_STATUS_CHANGED");
 140
 141                 MSG_CBMSG_OPT_S cbMsgOpt = {};
 142
 143                 if (getCbConfig(&cbMsgOpt) == true)
 144                 {
 145                         err = addCbOpt(&cbMsgOpt);
 146
 147                         if (err == MSG_SUCCESS)
 148                         {
 149                                 MSG_DEBUG("########  Add CB Option Success !!! #######");
 150                         }
 151                         else
 152                         {
 153                                 MSG_DEBUG("########  Add CB Option Fail !!! return : %d #######", err);
 154                         }
 155                 }
 156         }
 157         else if (SimStatus == MSG_SIM_STATUS_NORMAL)
 158         {
 159                 MSG_DEBUG("simStatus == MSG_SIM_STATUS_NORMAL");
 160
 161                 // Set CB Data into SIM in case of same SIM
 162                 MSG_SETTING_S cbSetting;
 163                 cbSetting.type = MSG_CBMSG_OPT;
 164
 165                 getCbOpt(&cbSetting);
 166
 167                 setCbConfig(&(cbSetting.option.cbMsgOpt));
 168         }
 169
 170         MSG_END();
 171 }
 172
 173
 174 void SmsPluginSetting::setConfigData(const MSG_SETTING_S *pSetting)
 175 {
 176         MSG_DEBUG("Setting Type : [%d]", pSetting->type);
 177
 178         switch (pSetting->type)
 179         {
 180                 case MSG_SMSC_LIST :
 181                         setParamList(&pSetting->option.smscList);
 182                 break;
 183
 184                 case MSG_CBMSG_OPT :
 185                         setCbConfig(&pSetting->option.cbMsgOpt);
 186                 break;
 187
 188                 default :
 189                         THROW(MsgException::SMS_PLG_ERROR, "The Setting type is not supported. [%d]", pSetting->type);
 190                 break;
 191         }
 192 }
 193
 194
 195 void SmsPluginSetting::getConfigData(MSG_SETTING_S *pSetting)
 196 {
 197         MSG_DEBUG("Setting Type : [%d]", pSetting->type);
 198
 199         switch (pSetting->type)
 200         {
 201                 case MSG_SMSC_LIST :
 202                         getParamList(&pSetting->option.smscList);
 203                 break;
 204
 205                 case MSG_CBMSG_OPT :
 206                         getCbConfig(&pSetting->option.cbMsgOpt);
 207                 break;
 208
 209                 default :
 210                         THROW(MsgException::SMS_PLG_ERROR, "The Setting type is not supported. [%d]", pSetting->type);
 211                 break;
 212         }
 213 }
 214
 215
 216 MSG_ERROR_T SmsPluginSetting::addSMSCList(MSG_SMSC_LIST_S *pSmscList)
 217 {
 218         MSG_ERROR_T err = MSG_SUCCESS;
 219
 220         MSG_DEBUG("total_count[%d]", pSmscList->totalCnt);
 221         MSG_DEBUG("selected index[%d]", pSmscList->selected);
 222
 223         for (int i = 0; i < pSmscList->totalCnt; i++)
 224         {
 225                 MSG_DEBUG("pid[%d]", pSmscList->smscData[i].pid);
 226                 MSG_DEBUG("val_period[%d]", pSmscList->smscData[i].valPeriod);
 227                 MSG_DEBUG("name[%s]", pSmscList->smscData[i].name);
 228
 229                 MSG_DEBUG("ton[%d]", pSmscList->smscData[i].smscAddr.ton);
 230                 MSG_DEBUG("npi[%d]", pSmscList->smscData[i].smscAddr.npi);
 231                 MSG_DEBUG("address[%s]", pSmscList->smscData[i].smscAddr.address);
 232         }
 233
 234         char keyName[128];
 235
 236         if (MsgSettingSetInt(SMSC_TOTAL_COUNT, pSmscList->totalCnt) != MSG_SUCCESS)
 237         {
 238                 MSG_DEBUG("Error to set config data [%s]", SMSC_TOTAL_COUNT);
 239                 return MSG_ERR_SET_SETTING;
 240         }
 241
 242         if (MsgSettingSetInt(SMSC_SELECTED, pSmscList->selected) != MSG_SUCCESS)
 243         {
 244                 MSG_DEBUG("Error to set config data [%s]", SMSC_SELECTED);
 245                 return MSG_ERR_SET_SETTING;
 246         }
 247
 248         for (int i = 0; i < pSmscList->totalCnt; i++)
 249         {
 250                 memset(keyName, 0x00, sizeof(keyName));
 251                 sprintf(keyName, "%s/%d", SMSC_PID, i);
 252
 253                 if ((err = MsgSettingSetInt(keyName, (int)pSmscList->smscData[i].pid)) != MSG_SUCCESS)
 254                         break;
 255
 256                 memset(keyName, 0x00, sizeof(keyName));
 257                 sprintf(keyName, "%s/%d", SMSC_VAL_PERIOD, i);
 258
 259                 if ((err = MsgSettingSetInt(keyName, (int)pSmscList->smscData[i].valPeriod)) != MSG_SUCCESS)
 260                         break;
 261
 262                 memset(keyName, 0x00, sizeof(keyName));
 263                 sprintf(keyName, "%s/%d", SMSC_NAME, i);
 264
 265                 if ((err = MsgSettingSetString(keyName, pSmscList->smscData[i].name)) != MSG_SUCCESS)
 266                         break;
 267
 268                 memset(keyName, 0x00, sizeof(keyName));
 269                 sprintf(keyName, "%s/%d", SMSC_TON, i);
 270
 271                 if (pSmscList->smscData[i].smscAddr.address[0] == '+')
 272                         pSmscList->smscData[i].smscAddr.ton = MSG_TON_INTERNATIONAL;
 273                 else
 274                         pSmscList->smscData[i].smscAddr.ton = MSG_TON_NATIONAL;
 275
 276                 if ((err = MsgSettingSetInt(keyName, (int)pSmscList->smscData[i].smscAddr.ton)) != MSG_SUCCESS)
 277                         break;
 278
 279                 memset(keyName, 0x00, sizeof(keyName));
 280                 sprintf(keyName, "%s/%d", SMSC_NPI, i);
 281
 282                 pSmscList->smscData[i].smscAddr.npi = MSG_NPI_ISDN; // app cannot set this value
 283
 284                 if ((err = MsgSettingSetInt(keyName, (int)pSmscList->smscData[i].smscAddr.npi)) != MSG_SUCCESS)
 285                         break;
 286
 287                 memset(keyName, 0x00, sizeof(keyName));
 288                 sprintf(keyName, "%s/%d", SMSC_ADDRESS, i);
 289
 290                 if ((err = MsgSettingSetString(keyName, pSmscList->smscData[i].smscAddr.address)) != MSG_SUCCESS)
 291                         break;
 292         }
 293
 294         if (err != MSG_SUCCESS)
 295         {
 296                 MSG_DEBUG("Error to set config data [%s]", keyName);
 297         }
 298
 299         return err;
 300 }
 301
 302
 303 MSG_ERROR_T SmsPluginSetting::addCbOpt(MSG_CBMSG_OPT_S *pCbOpt)
 304 {
 305         MSG_ERROR_T err = MSG_SUCCESS;
 306
 307         MSG_DEBUG("Receive [%d], All Channel [%d], Max SIM Count [%d]", pCbOpt->bReceive, pCbOpt->bAllChannel, pCbOpt->maxSimCnt);
 308
 309         MSG_DEBUG("Channel Count [%d]", pCbOpt->channelData.channelCnt);
 310
 311         for (int i = 0; i < pCbOpt->channelData.channelCnt; i++)
 312         {
 313                 MSG_DEBUG("Channel ID [%d]", pCbOpt->channelData.channelInfo[i].id);
 314         }
 315
 316         // Set Setting Data into Vconf
 317         if (MsgSettingSetBool(CB_RECEIVE, pCbOpt->bReceive) != MSG_SUCCESS)
 318         {
 319                 MSG_DEBUG("Error to set config data [%s]", CB_RECEIVE);
 320                 return MSG_ERR_SET_SETTING;
 321         }
 322
 323         if (MsgSettingSetBool(CB_ALL_CHANNEL, pCbOpt->bAllChannel) != MSG_SUCCESS)
 324         {
 325                 MSG_DEBUG("Error to set config data [%s]", CB_ALL_CHANNEL);
 326                 return MSG_ERR_SET_SETTING;
 327         }
 328
 329         if (MsgSettingSetInt(CB_MAX_SIM_COUNT, pCbOpt->maxSimCnt) != MSG_SUCCESS)
 330         {
 331                 MSG_DEBUG("Error to set config data [%s]", CB_MAX_SIM_COUNT);
 332                 return MSG_ERR_SET_SETTING;
 333         }
 334
 335         if (MsgSettingSetInt(CB_CHANNEL_COUNT, pCbOpt->channelData.channelCnt) != MSG_SUCCESS)
 336         {
 337                 MSG_DEBUG("Error to set config data [%s]", CB_CHANNEL_COUNT);
 338                 return MSG_ERR_SET_SETTING;
 339         }
 340
 341         char keyName[128];
 342
 343         for (int i = 0; i < pCbOpt->channelData.channelCnt; i++)
 344         {
 345                 memset(keyName, 0x00, sizeof(keyName));
 346                 sprintf(keyName, "%s/%d", CB_CHANNEL_ACTIVATE, i);
 347
 348                 if ((err = MsgSettingSetBool(keyName, pCbOpt->channelData.channelInfo[i].bActivate)) != MSG_SUCCESS)
 349                         break;
 350
 351                 memset(keyName, 0x00, sizeof(keyName));
 352                 sprintf(keyName, "%s/%d", CB_CHANNEL_ID, i);
 353
 354                 if ((err = MsgSettingSetInt(keyName, pCbOpt->channelData.channelInfo[i].id)) != MSG_SUCCESS)
 355                         break;
 356
 357                 memset(keyName, 0x00, sizeof(keyName));
 358                 sprintf(keyName, "%s/%d", CB_CHANNEL_NAME, i);
 359
 360                 if ((err = MsgSettingSetString(keyName, pCbOpt->channelData.channelInfo[i].name)) != MSG_SUCCESS)
 361                         break;
 362         }
 363
 364         return err;
 365 }
 366
 367
 368 void SmsPluginSetting::getCbOpt(MSG_SETTING_S *pSetting)
 369 {
 370         char keyName[128];
 371         char *tmpValue = NULL;
 372
 373         memset(&(pSetting->option.cbMsgOpt), 0x00, sizeof(MSG_CBMSG_OPT_S));
 374
 375         MsgSettingGetBool(CB_RECEIVE, &pSetting->option.cbMsgOpt.bReceive);
 376
 377         MsgSettingGetBool(CB_ALL_CHANNEL, &pSetting->option.cbMsgOpt.bAllChannel);
 378
 379         pSetting->option.cbMsgOpt.maxSimCnt = MsgSettingGetInt(CB_MAX_SIM_COUNT);
 380
 381         pSetting->option.cbMsgOpt.channelData.channelCnt = MsgSettingGetInt(CB_CHANNEL_COUNT);
 382
 383         for (int i = 0; i < pSetting->option.cbMsgOpt.channelData.channelCnt; i++)
 384         {
 385                 memset(keyName, 0x00, sizeof(keyName));
 386                 sprintf(keyName, "%s/%d", CB_CHANNEL_ACTIVATE, i);
 387
 388                 MsgSettingGetBool(keyName, &pSetting->option.cbMsgOpt.channelData.channelInfo[i].bActivate);
 389
 390                 memset(keyName, 0x00, sizeof(keyName));
 391                 sprintf(keyName, "%s/%d", CB_CHANNEL_ID, i);
 392
 393                 pSetting->option.cbMsgOpt.channelData.channelInfo[i].id = MsgSettingGetInt(keyName);
 394
 395                 memset(keyName, 0x00, sizeof(keyName));
 396                 sprintf(keyName, "%s/%d", CB_CHANNEL_NAME, i);
 397
 398                 tmpValue = MsgSettingGetString(keyName);
 399
 400                 if (tmpValue != NULL)
 401                 {
 402                         strncpy(pSetting->option.cbMsgOpt.channelData.channelInfo[i].name, tmpValue, CB_CHANNEL_NAME_MAX);
 403                         free(tmpValue);
 404                         tmpValue = NULL;
 405                 }
 406         }
 407
 408         for (int i = MSG_CBLANG_TYPE_ALL; i < MSG_CBLANG_TYPE_MAX; i++)
 409         {
 410                 memset(keyName, 0x00, sizeof(keyName));
 411                 sprintf(keyName, "%s/%d", CB_LANGUAGE, i);
 412
 413                 MsgSettingGetBool(keyName, &pSetting->option.cbMsgOpt.bLanguage[i]);
 414         }
 415
 416 }
 417
 418
 419 void SmsPluginSetting::setParamList(const MSG_SMSC_LIST_S *pSMSCList)
 420 {
 421         MSG_BEGIN();
 422
 423         TelSmsParams_t smsParam = {0};
 424
 425         int ret = TAPI_API_SUCCESS;
 426         int reqId = 0;
 427
 428         for (int index = 0; index < pSMSCList->totalCnt; index++)
 429         {
 430                 /*Setting the SMSP Record index value*/
 431                 smsParam.RecordIndex = (unsigned char)index;
 432
 433                 /*Setting the SMSP Record Length value = 28 + alphaId_len*/
 434                 smsParam.RecordLen = 28 + strlen(pSMSCList->smscData[index].name);
 435
 436                 /*Setting the SMSP Alpha ID value*/
 437                 smsParam.AlphaIdLen = strlen(pSMSCList->smscData[index].name);
 438                 MSG_DEBUG("AlphaIdLen = %ld", smsParam.AlphaIdLen);
 439
 440                 if (smsParam.AlphaIdLen > 0 &&  smsParam.AlphaIdLen <= SMSC_NAME_MAX)
 441                 {
 442                         memcpy(smsParam.szAlphaId, pSMSCList->smscData[index].name, smsParam.AlphaIdLen);
 443                         smsParam.szAlphaId[smsParam.AlphaIdLen] = '\0';
 444                         MSG_DEBUG("szAlphaId = %s", smsParam.szAlphaId);
 445                 }
 446
 447                 smsParam.ParamIndicator = 0x00;
 448
 449                 if (strlen(pSMSCList->smscData[index].smscAddr.address) > 0)
 450                 {
 451                         smsParam.ParamIndicator |= 0x02 ;  //enable 2nd Bit
 452                         MSG_DEBUG("ParamIndicator = [%02x]", smsParam.ParamIndicator);
 453
 454                         if (pSMSCList->smscData[index].smscAddr.address[0] == '+')
 455                                 smsParam.TpSvcCntrAddr.Ton = TAPI_SIM_TON_INTERNATIONAL;
 456                         else
 457                                 smsParam.TpSvcCntrAddr.Ton = TAPI_SIM_TON_NATIONAL;
 458
 459                         smsParam.TpSvcCntrAddr.Npi = TAPI_SIM_NPI_ISDN_TEL; // app cannot set this value
 460
 461                         MSG_DEBUG("SMSC TON = [%d] NPI = [%d]", smsParam.TpSvcCntrAddr.Ton, smsParam.TpSvcCntrAddr.Npi);
 462
 463                         MSG_DEBUG("address = %s", pSMSCList->smscData[index].smscAddr.address);
 464
 465                         smsParam.TpSvcCntrAddr.DialNumLen = SmsPluginParamCodec::encodeSMSC(pSMSCList->smscData[index].smscAddr.address, smsParam.TpSvcCntrAddr.szDiallingNum);
 466                 }
 467                 else
 468                 {
 469                         MSG_DEBUG("SMSC Addr is not present");
 470                 }
 471
 472                 /*Setting the PID value*/
 473                 smsParam.ParamIndicator |= 0x04 ;  //enable 3nd Bit
 474                 MSG_DEBUG("ParamIndicator = [%02x]", smsParam.ParamIndicator);
 475
 476                 smsParam.TpProtocolId = (unsigned short)convertPid(pSMSCList->smscData[index].pid);
 477
 478                 /*Setting the ValidityPeriod value*/
 479                 smsParam.ParamIndicator |= 0x10 ;  //enable 5nd Bit
 480                 MSG_DEBUG("ParamIndicator = [%02x]", smsParam.ParamIndicator);
 481
 482                 smsParam.TpValidityPeriod = (unsigned short)pSMSCList->smscData[index].valPeriod;
 483
 484                 smsParam.ParamIndicator = ~(smsParam.ParamIndicator);
 485                 MSG_DEBUG("ParamIndicator = [%02x]", smsParam.ParamIndicator);
 486
 487                 ret = tel_set_sms_parameters((const TelSmsParams_t*)&smsParam, &reqId);
 488
 489                 if (ret != TAPI_API_SUCCESS)
 490                         THROW(MsgException::SMS_PLG_ERROR, "tel_set_sms_parameters() Error. [%d]", ret);
 491
 492                 if (!getResultFromSim())
 493                         THROW(MsgException::SMS_PLG_ERROR, "tel_set_sms_parameters() Result Error.");
 494         }
 495
 496         MSG_END();
 497 }
 498
 499
 500 void SmsPluginSetting::getParamList(MSG_SMSC_LIST_S *pSMSCList)
 501 {
 502         MSG_BEGIN();
 503
 504         int paramCnt = 0;
 505
 506         paramCnt = getParamCount();
 507
 508         MSG_DEBUG("Parameter Count [%d]", paramCnt);
 509
 510         int ret = TAPI_API_SUCCESS;
 511         int reqId = 0;
 512
 513         MSG_SMSC_DATA_S tmpSmscData = {};
 514
 515         for (int index = 0; index < paramCnt; index++)
 516         {
 517                 ret = tel_get_sms_parameters(index, &reqId);
 518
 519                 if (ret == TAPI_API_SUCCESS)
 520                 {
 521                         MSG_DEBUG("######## tel_get_sms_parameters() Success !!! #######");
 522                 }
 523                 else
 524                 {
 525                         THROW(MsgException::SMS_PLG_ERROR, "######## tel_get_sms_parameters() Fail !!! return : %d #######", ret);
 526                 }
 527
 528                 if (getParamEvent(&tmpSmscData) == true)
 529                 {
 530                         MSG_DEBUG("######## Get Parameter was Successful !!! #######");
 531                 }
 532                 else
 533                 {
 534                         THROW(MsgException::SMS_PLG_ERROR, "######## Get Parameter was Failed !!! #######");
 535                 }
 536
 537                 memcpy(&(pSMSCList->smscData[index]), &tmpSmscData, sizeof(MSG_SMSC_DATA_S));
 538
 539                 MSG_DEBUG("pid[%d]", pSMSCList->smscData[index].pid);
 540                 MSG_DEBUG("val_period[%d]", pSMSCList->smscData[index].valPeriod);
 541                 MSG_DEBUG("name[%s]", pSMSCList->smscData[index].name);
 542
 543                 MSG_DEBUG("ton[%d]", pSMSCList->smscData[index].smscAddr.ton);
 544                 MSG_DEBUG("npi[%d]", pSMSCList->smscData[index].smscAddr.npi);
 545                 MSG_DEBUG("address[%s]", pSMSCList->smscData[index].smscAddr.address);
 546         }
 547
 548         pSMSCList->totalCnt = paramCnt;
 549         pSMSCList->selected = selectedParam;
 550
 551         MSG_DEBUG("total_count[%d]", pSMSCList->totalCnt);
 552
 553         MSG_END();
 554 }
 555
 556
 557 int SmsPluginSetting::getParamCount()
 558 {
 559         int reqId = 0;
 560
 561         int ret = TAPI_API_SUCCESS;
 562
 563         ret = tel_get_sms_parameter_count(&reqId);
 564
 565         if (ret == TAPI_API_SUCCESS)
 566         {
 567                 MSG_DEBUG("######## tel_get_sms_parameter_count() Success !!! #######");
 568         }
 569         else
 570         {
 571                 THROW(MsgException::SMS_PLG_ERROR, "tel_get_sms_parameter_count() Error. [%d]", ret);
 572         }
 573
 574         return getParamCntEvent();
 575 }
 576
 577
 578 bool SmsPluginSetting::getParam(int Index, MSG_SMSC_DATA_S *pSmscData)
 579 {
 580         int reqId = 0;
 581
 582         int ret = TAPI_API_SUCCESS;
 583
 584         ret = tel_get_sms_parameters(Index, &reqId);
 585
 586         if (ret == TAPI_API_SUCCESS)
 587         {
 588                 MSG_DEBUG("######## tel_get_sms_parameters() Success !!! #######");
 589         }
 590         else
 591         {
 592                 MSG_DEBUG("######## tel_get_sms_parameters() Fail !!! return : %d #######", ret);
 593                 return false;
 594         }
 595
 596         if (getParamEvent(pSmscData) == true)
 597         {
 598                 MSG_DEBUG("######## Get Parameter was Successful !!! #######");
 599         }
 600         else
 601         {
 602                 MSG_DEBUG("######## Get Parameter was Failed !!! #######");
 603                 return false;
 604         }
 605
 606         return true;
 607 }
 608
 609
 610 bool SmsPluginSetting::setCbConfig(const MSG_CBMSG_OPT_S *pCbOpt)
 611 {
 612         int reqId = 0;
 613
 614         int ret = TAPI_API_SUCCESS;
 615
 616         TelSmsCbConfig_t cbConfig = {};
 617
 618         cbConfig.bCBEnabled = (int)pCbOpt->bReceive;
 619
 620         if (pCbOpt->bAllChannel == true)
 621                 cbConfig.SelectedId = 0x01;
 622         else
 623                 cbConfig.SelectedId = 0x02;
 624
 625         cbConfig.MsgIdCount = pCbOpt->channelData.channelCnt;
 626
 627         for (int i = 0; i < cbConfig.MsgIdCount; i++)
 628         {
 629                 cbConfig.MsgIDs[i] = (unsigned short)pCbOpt->channelData.channelInfo[i].id;
 630         }
 631
 632         ret = tel_set_sms_cb_config(&cbConfig, &reqId);
 633
 634         if (ret == TAPI_API_SUCCESS)
 635         {
 636                 MSG_DEBUG("######## tel_set_sms_cb_config() Success !!! #######");
 637         }
 638         else
 639         {
 640                 MSG_DEBUG("######## tel_set_sms_cb_config() Fail !!! return : %d #######", ret);
 641                 return false;
 642         }
 643
 644         if (getResultFromSim() == true)
 645         {
 646                 MSG_DEBUG("######## Set Cb Config was Successful !!! #######");
 647         }
 648         else
 649         {
 650                 MSG_DEBUG("######## Set Cb Config was Failed !!! #######");
 651                 return false;
 652         }
 653
 654         return true;
 655 }
 656
 657
 658 bool SmsPluginSetting::getCbConfig(MSG_CBMSG_OPT_S *pCbOpt)
 659 {
 660         int reqId = 0;
 661
 662         int ret = TAPI_API_SUCCESS;
 663
 664         ret = tel_get_sms_cb_config(&reqId);
 665
 666         if (ret == TAPI_API_SUCCESS)
 667         {
 668                 MSG_DEBUG("######## tel_get_sms_cb_config() Success !!! #######");
 669         }
 670         else
 671         {
 672                 MSG_DEBUG("######## tel_get_sms_cb_config() Fail !!! return : %d #######", ret);
 673                 return false;
 674         }
 675
 676         if (getCbConfigEvent(pCbOpt) == true)
 677         {
 678                 MSG_DEBUG("######## Get Cb Config was Successful !!! #######");
 679         }
 680         else
 681         {
 682                 MSG_DEBUG("######## Get Cb Config was Failed !!! #######");
 683                 return false;
 684         }
 685
 686         return true;
 687 }
 688
 689
 690 void SmsPluginSetting::setParamCntEvent(int ParamCnt)
 691 {
 692         mx.lock();
 693
 694         paramCnt = ParamCnt;
 695
 696         cv.signal();
 697
 698         mx.unlock();
 699 }
 700
 701
 702 int SmsPluginSetting::getParamCntEvent()
 703 {
 704         int ret = 0;
 705
 706         mx.lock();
 707
 708         ret = cv.timedwait(mx.pMutex(), 10);
 709
 710         mx.unlock();
 711
 712         if (ret == ETIMEDOUT)
 713         {
 714                 MSG_DEBUG("WARNING: TAPI callback TIME-OUT");
 715                 return 0;
 716         }
 717
 718         return paramCnt;
 719 }
 720
 721
 722 void SmsPluginSetting::setParamEvent(const MSG_SMSC_DATA_S *pSmscData, int RecordIdx, bool bSuccess)
 723 {
 724         mx.lock();
 725
 726         bTapiResult = bSuccess;
 727
 728         memset(&smscData, 0x00, sizeof(MSG_SMSC_DATA_S));
 729
 730         if (bTapiResult == true)
 731         {
 732                 MSG_DEBUG("Success to get parameter data");
 733
 734                 selectedParam = RecordIdx;
 735
 736                 memcpy(&smscData, pSmscData, sizeof(MSG_SMSC_DATA_S));
 737         }
 738
 739         cv.signal();
 740
 741         mx.unlock();
 742 }
 743
 744
 745 bool SmsPluginSetting::getParamEvent(MSG_SMSC_DATA_S *pSmscData)
 746 {
 747         int ret = 0;
 748
 749         bTapiResult = false;
 750
 751         mx.lock();
 752
 753         ret = cv.timedwait(mx.pMutex(), 10);
 754
 755         mx.unlock();
 756
 757         if (ret == ETIMEDOUT)
 758         {
 759                 MSG_DEBUG("WARNING: TAPI callback TIME-OUT");
 760                 return false;
 761         }
 762
 763         memset(pSmscData, 0x00, sizeof(MSG_SMSC_DATA_S));
 764
 765         if (bTapiResult == true)
 766         {
 767                 memcpy(pSmscData, &smscData, sizeof(MSG_SMSC_DATA_S));
 768         }
 769
 770         return bTapiResult;
 771 }
 772
 773
 774 void SmsPluginSetting::setCbConfigEvent(const MSG_CBMSG_OPT_S *pCbOpt, bool bSuccess)
 775 {
 776         mx.lock();
 777
 778         bTapiResult = bSuccess;
 779
 780         memset(&cbOpt, 0x00, sizeof(MSG_CBMSG_OPT_S));
 781
 782         if (bTapiResult == true)
 783         {
 784                 MSG_DEBUG("Success to get cb config data");
 785
 786                 memcpy(&cbOpt, pCbOpt, sizeof(MSG_CBMSG_OPT_S));
 787         }
 788
 789         cv.signal();
 790
 791         mx.unlock();
 792 }
 793
 794
 795 bool SmsPluginSetting::getCbConfigEvent(MSG_CBMSG_OPT_S *pCbOpt)
 796 {
 797         int ret = 0;
 798
 799         bTapiResult = false;
 800
 801         mx.lock();
 802
 803         ret = cv.timedwait(mx.pMutex(), 10);
 804
 805         mx.unlock();
 806
 807         if (ret == ETIMEDOUT)
 808         {
 809                 MSG_DEBUG("WARNING: TAPI callback TIME-OUT");
 810                 return false;
 811         }
 812
 813         memset(pCbOpt, 0x00, sizeof(MSG_CBMSG_OPT_S));
 814
 815         if (bTapiResult == true)
 816         {
 817                 memcpy(pCbOpt, &cbOpt, sizeof(MSG_CBMSG_OPT_S));
 818         }
 819
 820         return bTapiResult;
 821 }
 822
 823
 824 void SmsPluginSetting::setResultFromSim(bool bResult)
 825 {
 826         mx.lock();
 827
 828         bTapiResult = bResult;
 829
 830         cv.signal();
 831
 832         mx.unlock();
 833 }
 834
 835
 836 bool SmsPluginSetting::getResultFromSim()
 837 {
 838         int ret = 0;
 839
 840         mx.lock();
 841
 842         ret = cv.timedwait(mx.pMutex(), 10);
 843
 844         mx.unlock();
 845
 846         if (ret == ETIMEDOUT)
 847         {
 848                 MSG_DEBUG("WARNING: TAPI callback TIME-OUT");
 849                 return false;
 850         }
 851
 852         return bTapiResult;
 853 }
 854
 855
 856 SMS_PID_T SmsPluginSetting::convertPid(MSG_SMS_PID_T pid)
 857 {
 858         SMS_PID_T retPid;
 859
 860         switch (pid)
 861         {
 862                 case MSG_PID_TEXT :
 863                         retPid = SMS_PID_NORMAL;
 864                 break;
 865                 case MSG_PID_VOICE :
 866                         retPid = SMS_PID_VOICE;
 867                 break;
 868                 case MSG_PID_FAX :
 869                         retPid = SMS_PID_TELEX;
 870                 break;
 871                 case MSG_PID_X400 :
 872                         retPid = SMS_PID_x400;
 873                 break;
 874                 case MSG_PID_ERMES :
 875                         retPid = SMS_PID_ERMES;
 876                 break;
 877                 case MSG_PID_EMAIL :
 878                         retPid = SMS_PID_EMAIL;
 879                 break;
 880                 default :
 881                         retPid = SMS_PID_NORMAL;
 882                 break;
 883         }
 884
 885         return retPid;
 886 }
 887