src/PhnSettingsManager.cpp

   1 //
   2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Flora License, Version 1.1 (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://floralicense.org/license/
   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 /**
  18  * @file    PhnSettingsManager.cpp
  19  * @brief   Setting Manager class
  20  */
  21 #include <libintl.h>
  22 #include <FApp.h>
  23 #include <FSocial.h>
  24 #include <FBaseColIList.h>
  25 #include "vconf.h"
  26 #include "vconf-internal-ciss-keys.h"
  27 #include "PhnAppUtility.h"
  28 #include "PhnSettingsManager.h"
  29 #include "PhnTypes.h"
  30
  31 using namespace Tizen::App;
  32 using namespace Tizen::Base;
  33 using namespace Tizen::Base::Collection;
  34 using namespace Tizen::Io;
  35 using namespace Tizen::Social;
  36 using namespace Tizen::System;
  37
  38 SettingsManager* SettingsManager::__pInstance = null;
  39
  40 SettingsManager::SettingsManager(void)
  41         : __pTapiHandle(null)
  42         , __pSettingsEventListener(null)
  43         , __pCallSettingDataService(null)
  44         ,__pMsgHandle(null)
  45         ,__pNumberFilterIndex(null)
  46 {
  47
  48 }
  49
  50 SettingsManager::~SettingsManager(void)
  51 {
  52         //De-initialize the TAPI Library
  53         if(__pTapiHandle != null)
  54         {
  55                 tel_deinit(__pTapiHandle);
  56         }
  57         if (__pCallSettingDataService)
  58         {
  59                 __pCallSettingDataService->CloseDatabase();
  60                 delete __pCallSettingDataService;
  61         }
  62         if (__pSettingsEventListener != null)
  63         {
  64                 delete __pSettingsEventListener;
  65         }
  66         if(__pNumberFilterIndex != null)
  67         {
  68                 delete __pNumberFilterIndex;
  69                 __pNumberFilterIndex = null;
  70         }
  71         RemoveSystemEventListener();
  72         CloseMsgHandleSession();
  73 }
  74
  75 void SettingsManager::CreateInstance(void)
  76 {
  77         __pInstance = new (std::nothrow) SettingsManager();
  78         result r = __pInstance->Construct();
  79         if(IsFailed(r))
  80         {
  81                 delete __pInstance;
  82                 __pInstance = null;
  83                 return;
  84         }
  85         std::atexit(&(SettingsManager::DestroyInstance));
  86 }
  87
  88 void SettingsManager::DestroyInstance(void)
  89 {
  90         delete __pInstance;
  91 }
  92
  93 result
  94 SettingsManager::Construct(void)
  95 {
  96         __pCallSettingDataService = CallSettingDataService::CreateInstance();
  97         result r = __pCallSettingDataService->OpenDatabase();
  98         if(IsFailed(r))
  99         {
 100                 return E_FAILURE;
 101         }
 102         //initialize telephony
 103         __pTapiHandle = tel_init(null);
 104         AddSystemEventListener();
 105
 106         if(__pNumberFilterIndex == null)
 107         {
 108                 __pNumberFilterIndex = new (std::nothrow) ArrayListT< int>();
 109                 __pNumberFilterIndex->Construct();
 110         }
 111
 112         return E_SUCCESS;
 113 }
 114
 115 SettingsManager*
 116 SettingsManager::GetInstance(void)
 117 {
 118         if (__pInstance == null)
 119         {
 120                 CreateInstance();
 121         }
 122         return __pInstance;
 123 }
 124
 125 void
 126 SettingsManager::AddSettingEventListener(ISettingsEventListener* pSettingsEventListener)
 127 {
 128         if (__pSettingsEventListener == null)
 129         {
 130                 __pSettingsEventListener = new (std::nothrow) ArrayListT<ISettingsEventListener*>();
 131         }
 132
 133         //Add to listeners, if not already in list.
 134         if ( (pSettingsEventListener != null)
 135                         && !(__pSettingsEventListener->Contains(pSettingsEventListener)) )
 136         {
 137                 __pSettingsEventListener->Add(pSettingsEventListener);
 138         }
 139 }
 140
 141 void
 142 SettingsManager::RemoveSettingEventListener(ISettingsEventListener* pSettingsEventListener)
 143 {
 144         if ((__pSettingsEventListener != null) && (pSettingsEventListener != null)
 145                         && __pSettingsEventListener->Contains(pSettingsEventListener))
 146         {
 147                 __pSettingsEventListener->Remove(pSettingsEventListener);
 148         }
 149 }
 150
 151 void
 152 SettingsManager::NotifyForwardingEventListeners(ForwardResponseType responseType, bool isCallSuccessful, CallForwardCondition callFwdCondition, const Tizen::Base::String& callFwdNumber, bool isCallForwardActivated, int noReplyWaitTime)
 153 {
 154         IEnumeratorT<ISettingsEventListener*>* pListenerEnum = null;
 155         result r = E_FAILURE;
 156         if (__pSettingsEventListener != null)
 157         {
 158                 pListenerEnum = __pSettingsEventListener->GetEnumeratorN();
 159                 //TryReturn(pListenerEnum != null, GetLastResult(), "[%s] Propagated.", GetErrorMessage(GetLastResult()));
 160
 161                 while ((r = pListenerEnum->MoveNext()) != E_OUT_OF_RANGE)
 162                 {
 163                         ISettingsEventListener* pListener;
 164                         r = pListenerEnum->GetCurrent(pListener);
 165                         //TryCatch(r == E_SUCCESS, , "[%s] Propagated.", GetErrorMessage(r));
 166                         if (responseType == SET_CALLFORWARD_RESPONSE)
 167                         {
 168                                 pListener->HandleSetCallForwardResponse(isCallSuccessful, callFwdCondition, callFwdNumber, isCallForwardActivated, noReplyWaitTime);
 169                         }
 170                         else
 171                         {
 172                                 pListener->HandleGetCallForwardResponse(isCallSuccessful, callFwdCondition, callFwdNumber, isCallForwardActivated, noReplyWaitTime);
 173                         }
 174                 }
 175         }
 176 }
 177
 178 void
 179 SettingsManager::NotifyBarringEventListeners(BarringResponseType responseType, bool isCallSuccessful, CallBarringType callBarringType, bool isBarringActivated)
 180 {
 181         IEnumeratorT<ISettingsEventListener*>* pListenerEnum = null;
 182         result r = E_FAILURE;
 183         if (__pSettingsEventListener != null)
 184         {
 185                 pListenerEnum = __pSettingsEventListener->GetEnumeratorN();
 186                 //TryReturn(pListenerEnum != null, GetLastResult(), "[%s] Propagated.", GetErrorMessage(GetLastResult()));
 187
 188                 while ((r = pListenerEnum->MoveNext()) != E_OUT_OF_RANGE)
 189                 {
 190                         ISettingsEventListener* pListener;
 191                         r = pListenerEnum->GetCurrent(pListener);
 192                         //TryCatch(r == E_SUCCESS, , "[%s] Propagated.", GetErrorMessage(r));
 193                         if (responseType == SET_CALLBARRING_RESPONSE)
 194                         {
 195                                 pListener->HandleSetCallBarringResponse(isCallSuccessful, callBarringType, isBarringActivated);
 196                         }
 197                         else
 198                         {
 199                                 pListener->HandleGetCallBarringResponse(isCallSuccessful, callBarringType, isBarringActivated);
 200                         }
 201                 }
 202         }
 203 }
 204
 205 void
 206 SettingsManager::NotifyWaitingEventListeners(WaitingResponseType responseType, bool isCallSuccessful, bool isCallWaitingActivated)
 207 {
 208         IEnumeratorT<ISettingsEventListener*>* pListenerEnum = null;
 209         result r = E_FAILURE;
 210         if (__pSettingsEventListener != null)
 211         {
 212                 pListenerEnum = __pSettingsEventListener->GetEnumeratorN();
 213                 //TryReturn(pListenerEnum != null, GetLastResult(), "[%s] Propagated.", GetErrorMessage(GetLastResult()));
 214
 215                 while ((r = pListenerEnum->MoveNext()) != E_OUT_OF_RANGE)
 216                 {
 217                         ISettingsEventListener* pListener;
 218                         r = pListenerEnum->GetCurrent(pListener);
 219                         //TryCatch(r == E_SUCCESS, , "[%s] Propagated.", GetErrorMessage(r));
 220                         if (responseType == SET_CALLWAITING_RESPONSE)
 221                         {
 222                                 pListener->HandleSetCallWaitingResponse(isCallSuccessful, isCallWaitingActivated);
 223                         }
 224                         else
 225                         {
 226                                 pListener->HandleGetCallWaitingResponse(isCallSuccessful, isCallWaitingActivated);
 227                         }
 228                 }
 229                 delete pListenerEnum;
 230         }
 231 }
 232
 233 int
 234 SettingsManager::SetCallForwardStatus(const String& phoneNumber, CallForwardCondition callFwdCondition, bool activateFwding, int noReplyTime)
 235 {
 236         int errorCode = ERROR_NONE;
 237         TryReturn(__pTapiHandle != null, ERROR_TAPI_INIT_FAILED, "Telephony initialization failed");
 238
 239         TelSsForwardInfo_t forwardInfo;
 240         memset(&forwardInfo, 0, sizeof(TelSsForwardInfo_t));
 241         forwardInfo.Class = TAPI_SS_CLASS_VOICE;
 242         if (activateFwding == true)
 243         {
 244                 forwardInfo.Mode = TAPI_SS_CF_MODE_REGISTRATION_EV;
 245         }
 246         else
 247         {
 248                 forwardInfo.Mode = TAPI_SS_CF_MODE_ERASURE_EV;
 249         }
 250         const wchar_t* pContact = phoneNumber.GetPointer();
 251         int len = phoneNumber.GetLength()+1;
 252         char* pNumber = new (std::nothrow) char[len];
 253         wcstombs(pNumber, pContact, len);
 254         strncpy(forwardInfo.szPhoneNumber, pNumber, len);
 255         delete []pNumber;
 256         pNumber = null;
 257         switch (callFwdCondition)
 258         {
 259         case CALL_FORWARD_ALL:
 260         {
 261                 forwardInfo.Condition = TAPI_SS_CF_WHEN_CFU;
 262         }
 263         break;
 264
 265         case CALL_FORWARD_BUSY:
 266         {
 267                 forwardInfo.Condition = TAPI_SS_CF_WHEN_CFB;
 268         }
 269         break;
 270
 271         case CALL_FORWARD_NO_REPLY:
 272         {
 273                 forwardInfo.Condition = TAPI_SS_CF_WHEN_CFNRy;
 274                 forwardInfo.NoReplyConditionTimer = TelSsNoReplyTime_t(noReplyTime);
 275         }
 276         break;
 277
 278         case CALL_FORWARD_NOT_REACHABLE:
 279         {
 280                 forwardInfo.Condition = TAPI_SS_CF_WHEN_CFNRc;
 281         }
 282         break;
 283
 284         default:
 285         {
 286                 return ERROR_INVALID_INPUT;
 287         }
 288         break;
 289         }
 290
 291         int retStatus = tel_set_ss_forward(__pTapiHandle, &forwardInfo, &HandleSetForwardResponse, this);
 292         if (retStatus != TAPI_API_SUCCESS)
 293         {
 294                 errorCode = ERROR_TAPI_ERROR;
 295         }
 296         return errorCode;
 297 }
 298
 299 void
 300 SettingsManager::HandleSetForwardResponse(TapiHandle* pHandle, int result, void* pData, void* pUserData)
 301 {
 302         TelSsForwardResp_t* pResponse = (TelSsForwardResp_t*) pData;
 303         SettingsManager* pSettingsManager = (SettingsManager*) pUserData;
 304         if (pResponse != null)
 305         {
 306                 int count = pResponse->record_num;
 307                 for (int index = 0; index < count; index++)
 308                 {
 309                         CallForwardCondition callFwdCondition = CALL_FORWARD_ALL;
 310                         bool isActivated = false;
 311                         int noReplyWaitTime = 0;
 312                         //Check if status is "Active or Quiescent" and forwarding number is available
 313                         if ((pResponse->record[index].Status == TAPI_SS_STATUS_ACTIVE
 314                                         || pResponse->record[index].Status == TAPI_SS_STATUS_QUIESCENT
 315                                         || pResponse->record[index].Status == TAPI_SS_STATUS_REGISTERED)
 316                                         && (pResponse->record[index].bCallForwardingNumberPresent != 0))
 317                         {
 318                                 isActivated = true;
 319                         }
 320                         switch (pResponse->record[index].ForwardCondition)
 321                         {
 322                         case TAPI_SS_CF_WHEN_CFU:
 323                         {
 324                                 callFwdCondition = CALL_FORWARD_ALL;
 325                         }
 326                         break;
 327
 328                         case TAPI_SS_CF_WHEN_CFB:
 329                         {
 330                                 callFwdCondition = CALL_FORWARD_BUSY;
 331                         }
 332                         break;
 333
 334                         case TAPI_SS_CF_WHEN_CFNRy:
 335                         {
 336                                 callFwdCondition = CALL_FORWARD_NO_REPLY;
 337                                 //fetch WaitTime
 338                                 noReplyWaitTime = (pResponse->record[index].NoReplyWaitTime);
 339                         }
 340                         break;
 341
 342                         case TAPI_SS_CF_WHEN_CFNRc:
 343                         {
 344                                 callFwdCondition = CALL_FORWARD_NOT_REACHABLE;
 345                         }
 346                         break;
 347
 348                         default:
 349                                 break;
 350                         }
 351                         //fetch forwarding number
 352                         char* pTmpNumberPtr = new (std::nothrow) char[TAPI_CALL_DIALDIGIT_LEN_MAX];
 353                         strncpy(pTmpNumberPtr, (char*) (pResponse->record[index].szCallForwardingNumber), TAPI_CALL_DIALDIGIT_LEN_MAX);
 354                         String callFwdNumber(pTmpNumberPtr);
 355                         delete []pTmpNumberPtr;
 356                         pTmpNumberPtr = null;
 357
 358                         //notify event listeners
 359                         pSettingsManager->NotifyForwardingEventListeners(SET_CALLFORWARD_RESPONSE,(result == TAPI_SS_SUCCESS),callFwdCondition, callFwdNumber, isActivated, noReplyWaitTime);
 360                 }
 361         }
 362 }
 363
 364 int
 365 SettingsManager::GetCallForwardStatus(CallForwardCondition callFwdCondition)
 366 {
 367         int errorCode = ERROR_NONE;
 368         TryReturn(__pTapiHandle != null,ERROR_TAPI_INIT_FAILED,"Telephony initialization failed");
 369
 370         TelSsForwardWhen_t condition;
 371         switch (callFwdCondition)
 372         {
 373         case CALL_FORWARD_ALL:
 374         {
 375                 condition = TAPI_SS_CF_WHEN_CFU;
 376         }
 377         break;
 378
 379         case CALL_FORWARD_BUSY:
 380         {
 381                 condition = TAPI_SS_CF_WHEN_CFB;
 382         }
 383         break;
 384
 385         case CALL_FORWARD_NO_REPLY:
 386         {
 387                 condition = TAPI_SS_CF_WHEN_CFNRy;
 388         }
 389         break;
 390
 391         case CALL_FORWARD_NOT_REACHABLE:
 392         {
 393                 condition = TAPI_SS_CF_WHEN_CFNRc;
 394         }
 395         break;
 396
 397         default:
 398         {
 399                 return ERROR_INVALID_INPUT;
 400         }
 401         break;
 402         }
 403         int retStatus = tel_get_ss_forward_status(__pTapiHandle, TAPI_SS_CLASS_VOICE, condition, &HandleGetForwardResponse, this);
 404         if (retStatus != TAPI_API_SUCCESS)
 405         {
 406                 errorCode = ERROR_TAPI_ERROR;
 407         }
 408
 409         return errorCode;
 410 }
 411
 412 void
 413 SettingsManager::HandleGetForwardResponse(TapiHandle* pHandle, int result, void* pData, void* pUserData)
 414 {
 415         TelSsForwardResp_t* pResponse = (TelSsForwardResp_t*) pData;
 416         SettingsManager* pSettingsManager = (SettingsManager*) pUserData;
 417         if (pResponse != null)
 418         {
 419                 int count = pResponse->record_num;
 420                 for (int index = 0; index < count; index++)
 421                 {
 422                         CallForwardCondition callFwdCondition = CALL_FORWARD_ALL;
 423                         bool isActivated = false;
 424                         int noReplyWaitTime = 0;
 425                         //Check if status is "ACTIVE or QUIESCENT or REGISTERED" and forwarding number is available
 426                         if ((pResponse->record[index].Status == TAPI_SS_STATUS_ACTIVE
 427                                         || pResponse->record[index].Status == TAPI_SS_STATUS_QUIESCENT
 428                                         || pResponse->record[index].Status == TAPI_SS_STATUS_REGISTERED)
 429                                         && (pResponse->record[index].bCallForwardingNumberPresent != 0))
 430                         {
 431                                 isActivated = true;
 432                         }
 433                         switch (pResponse->record[index].ForwardCondition)
 434                         {
 435                         case TAPI_SS_CF_WHEN_CFU:
 436                         {
 437                                 callFwdCondition = CALL_FORWARD_ALL;
 438                         }
 439                         break;
 440
 441                         case TAPI_SS_CF_WHEN_CFB:
 442                         {
 443                                 callFwdCondition = CALL_FORWARD_BUSY;
 444                         }
 445                         break;
 446
 447                         case TAPI_SS_CF_WHEN_CFNRy:
 448                         {
 449                                 callFwdCondition = CALL_FORWARD_NO_REPLY;
 450                                 noReplyWaitTime = (pResponse->record[index].NoReplyWaitTime);
 451                         }
 452                         break;
 453
 454                         case TAPI_SS_CF_WHEN_CFNRc:
 455                         {
 456                                 callFwdCondition = CALL_FORWARD_NOT_REACHABLE;
 457                         }
 458                         break;
 459
 460                         default:
 461                                 break;
 462                         }
 463                         char* pTmpNumberPtr = new (std::nothrow) char[TAPI_CALL_DIALDIGIT_LEN_MAX];
 464                         strncpy(pTmpNumberPtr, (char*) (pResponse->record[index].szCallForwardingNumber), TAPI_CALL_DIALDIGIT_LEN_MAX);
 465                         String callFwdNumber(pTmpNumberPtr);
 466                         //notify event listeners
 467                         pSettingsManager->NotifyForwardingEventListeners(GET_CALLFORWARD_RESPONSE, (result == TAPI_SS_SUCCESS), callFwdCondition, callFwdNumber, isActivated, noReplyWaitTime);
 468                         delete []pTmpNumberPtr;
 469                         pTmpNumberPtr = null;
 470                 }
 471         }
 472 }
 473
 474 int
 475 SettingsManager::SetCallBarringStatus(const String& password, CallBarringType callBarringType, bool activateBarring)
 476 {
 477         AppLog("%d %d",callBarringType,activateBarring);
 478         int errorCode = ERROR_NONE;
 479         TryReturn(__pTapiHandle != null, ERROR_TAPI_INIT_FAILED, "Telephony initialization failed");
 480
 481         TelSsBarringInfo_t barringInfo;
 482         memset(&barringInfo, 0, sizeof(TelSsBarringInfo_t));
 483         barringInfo.Class = TAPI_SS_CLASS_VOICE;
 484         if (activateBarring == true)
 485         {
 486                 barringInfo.Mode = TAPI_SS_CB_MODE_ACTIVATE;
 487         }
 488         else
 489         {
 490                 barringInfo.Mode = TAPI_SS_CB_MODE_DEACTIVATE;
 491         }
 492         const wchar_t* pContact = password.GetPointer();
 493         int len = password.GetLength();
 494         if (len > 4)
 495         {
 496                 return ERROR_BARRING_PWD_TOO_LONG;
 497         }
 498         char* pNumber = new (std::nothrow) char[len];
 499         wcstombs(pNumber, pContact, len);
 500         strncpy(barringInfo.szPassword, pNumber, len);
 501         delete []pNumber;
 502         pNumber = null;
 503         switch (callBarringType)
 504         {
 505         case CALL_BARRING_ALL_OUTGOING:
 506         {
 507                 barringInfo.Type = TAPI_SS_CB_TYPE_BAOC;
 508         }
 509         break;
 510
 511         case CALL_BARRING_INTERNATIONAL_OUTGOING:
 512         {
 513                 barringInfo.Type = TAPI_SS_CB_TYPE_BOIC;
 514         }
 515         break;
 516
 517         case CALL_BARRING_INTERNATIONAL_EXCEPT_HOME:
 518         {
 519                 barringInfo.Type = TAPI_SS_CB_TYPE_BOIC_NOT_HC;
 520         }
 521         break;
 522
 523         case CALL_BARRING_ALL_INCOMING:
 524         {
 525                 barringInfo.Type = TAPI_SS_CB_TYPE_BAIC;
 526         }
 527         break;
 528
 529         case CALL_BARRING_INCOMING_ROAMING:
 530         {
 531                 barringInfo.Type = TAPI_SS_CB_TYPE_BIC_ROAM;
 532         }
 533         break;
 534
 535         default:
 536         {
 537                 return ERROR_INVALID_INPUT;
 538         }
 539         break;
 540         }
 541         int retStatus = tel_set_ss_barring(__pTapiHandle, &barringInfo, &HandleSetBarringResponse, this);
 542         if (retStatus != TAPI_API_SUCCESS)
 543         {
 544                 errorCode = ERROR_TAPI_ERROR;
 545         }
 546
 547         return errorCode;
 548 }
 549
 550 void
 551 SettingsManager::HandleSetBarringResponse(TapiHandle* pHandle, int result, void* pData, void* pUserData)
 552 {
 553         TelSsBarringResp_t* pResponse = (TelSsBarringResp_t*) pData;
 554         SettingsManager* pSettingsManager = (SettingsManager*) pUserData;
 555         if (pResponse != null)
 556         {
 557                 CallBarringType callBarringType = CALL_BARRING_ALL_OUTGOING;
 558                 bool isActivated = false;
 559                 int count = pResponse->record_num;
 560                 for (int index = 0; index < count; index++)
 561                 {
 562                         if (pResponse->record[index].Status == TAPI_SS_STATUS_ACTIVE)
 563                         {
 564                                 isActivated = true;
 565                         }
 566                         switch (pResponse->record[index].Flavour)
 567                         {
 568                         case TAPI_SS_CB_TYPE_BAOC:
 569                         {
 570                                 callBarringType = CALL_BARRING_ALL_OUTGOING;
 571                         }
 572                         break;
 573
 574                         case TAPI_SS_CB_TYPE_BOIC:
 575                         {
 576                                 callBarringType = CALL_BARRING_INTERNATIONAL_OUTGOING;
 577                         }
 578                         break;
 579
 580                         case TAPI_SS_CB_TYPE_BOIC_NOT_HC:
 581                         {
 582                                 callBarringType = CALL_BARRING_INTERNATIONAL_EXCEPT_HOME;
 583                         }
 584                         break;
 585
 586                         case TAPI_SS_CB_TYPE_BAIC:
 587                         {
 588                                 callBarringType = CALL_BARRING_ALL_INCOMING;
 589                         }
 590                         break;
 591
 592                         case TAPI_SS_CB_TYPE_BIC_ROAM:
 593                         {
 594                                 callBarringType = CALL_BARRING_INCOMING_ROAMING;
 595                         }
 596                         break;
 597
 598                         default:
 599                                 break;
 600                         }
 601                         //notify event listeners
 602                         pSettingsManager->NotifyBarringEventListeners(SET_CALLBARRING_RESPONSE,(result == TAPI_SS_SUCCESS), callBarringType, isActivated);
 603                 }
 604         }
 605 }
 606
 607 int
 608 SettingsManager::GetCallBarringStatus(CallBarringType callBarringType)
 609 {
 610         int errorCode = ERROR_NONE;
 611         TryReturn(__pTapiHandle != null, ERROR_TAPI_INIT_FAILED, "Telephony initialization failed");
 612
 613         TelSsBarringType_t barringType;
 614         switch (callBarringType)
 615         {
 616         case CALL_BARRING_ALL_OUTGOING:
 617         {
 618                 barringType = TAPI_SS_CB_TYPE_BAOC;
 619         }
 620         break;
 621
 622         case CALL_BARRING_INTERNATIONAL_OUTGOING:
 623         {
 624                 barringType = TAPI_SS_CB_TYPE_BOIC;
 625         }
 626         break;
 627
 628         case CALL_BARRING_INTERNATIONAL_EXCEPT_HOME:
 629         {
 630                 barringType = TAPI_SS_CB_TYPE_BOIC_NOT_HC;
 631         }
 632         break;
 633
 634         case CALL_BARRING_ALL_INCOMING:
 635         {
 636                 barringType = TAPI_SS_CB_TYPE_BAIC;
 637         }
 638         break;
 639
 640         case CALL_BARRING_INCOMING_ROAMING:
 641         {
 642                 barringType = TAPI_SS_CB_TYPE_BIC_ROAM;
 643         }
 644         break;
 645
 646         default:
 647         {
 648                 return ERROR_INVALID_INPUT;
 649         }
 650         break;
 651         }
 652         int retStatus = tel_get_ss_barring_status(__pTapiHandle, TAPI_SS_CLASS_VOICE, barringType, &HandleGetBarringResponse, this);
 653         if (retStatus != TAPI_API_SUCCESS)
 654         {
 655                 errorCode = ERROR_TAPI_ERROR;
 656         }
 657
 658         return errorCode;
 659 }
 660
 661 void
 662 SettingsManager::HandleGetBarringResponse(TapiHandle* pHandle, int result, void* pData, void* pUserData)
 663 {
 664         TelSsBarringResp_t* pResponse = (TelSsBarringResp_t*) pData;
 665         SettingsManager* pSettingsManager = (SettingsManager*) pUserData;
 666         if (pResponse != null)
 667         {
 668                 CallBarringType callBarringType = CALL_BARRING_ALL_OUTGOING;
 669                 bool isActivated = false;
 670                 int count = pResponse->record_num;
 671                 for (int index = 0; index < count; index++)
 672                 {
 673                         if (pResponse->record[index].Status == TAPI_SS_STATUS_ACTIVE)
 674                         {
 675                                 isActivated = true;
 676                         }
 677                         switch (pResponse->record[index].Flavour)
 678                         {
 679                         case TAPI_SS_CB_TYPE_BAOC:
 680                         {
 681                                 callBarringType = CALL_BARRING_ALL_OUTGOING;
 682                         }
 683                         break;
 684
 685                         case TAPI_SS_CB_TYPE_BOIC:
 686                         {
 687                                 callBarringType = CALL_BARRING_INTERNATIONAL_OUTGOING;
 688                         }
 689                         break;
 690
 691                         case TAPI_SS_CB_TYPE_BOIC_NOT_HC:
 692                         {
 693                                 callBarringType = CALL_BARRING_INTERNATIONAL_EXCEPT_HOME;
 694                         }
 695                         break;
 696
 697                         case TAPI_SS_CB_TYPE_BAIC:
 698                         {
 699                                 callBarringType = CALL_BARRING_ALL_INCOMING;
 700                         }
 701                         break;
 702
 703                         case TAPI_SS_CB_TYPE_BIC_ROAM:
 704                         {
 705                                 callBarringType = CALL_BARRING_INCOMING_ROAMING;
 706                         }
 707                         break;
 708
 709                         default:
 710                                 break;
 711                         }
 712                         //notify event listeners
 713                         pSettingsManager->NotifyBarringEventListeners(GET_CALLBARRING_RESPONSE,(result == TAPI_SS_SUCCESS), callBarringType, isActivated);
 714                 }
 715         }
 716 }
 717
 718 int
 719 SettingsManager::SetCallWaitingStatus(bool activateWaiting)
 720 {
 721         int errorCode = ERROR_NONE;
 722         TryReturn(__pTapiHandle != null, ERROR_TAPI_INIT_FAILED,"Telephony initialization failed");
 723
 724         TelSsWaitingInfo_t waitingInfo;
 725         memset(&waitingInfo, 0, sizeof(TelSsWaitingInfo_t));
 726         waitingInfo.Class = TAPI_SS_CLASS_VOICE;
 727         if (activateWaiting == true)
 728         {
 729                 waitingInfo.Mode = TAPI_SS_CW_MODE_ACTIVATE;
 730         }
 731         else
 732         {
 733                 waitingInfo.Mode = TAPI_SS_CW_MODE_DEACTIVATE;
 734         }
 735         int retStatus = tel_set_ss_waiting(__pTapiHandle, &waitingInfo, &HandleSetWaitingResponse, this);
 736         if (retStatus != TAPI_API_SUCCESS)
 737         {
 738                 errorCode = ERROR_TAPI_ERROR;
 739         }
 740
 741         return errorCode;
 742 }
 743
 744 void
 745 SettingsManager::HandleSetWaitingResponse(TapiHandle* pHandle, int result, void* pData, void* pUserData)
 746 {
 747         TelSsWaitingResp_t* pResponse = (TelSsWaitingResp_t*) pData;
 748         SettingsManager* pSettingsManager = (SettingsManager*) pUserData;
 749         bool isCallSuccessful = false;
 750         if (result == TAPI_SS_SUCCESS)
 751         {
 752                 isCallSuccessful = true;
 753         }
 754         if (pResponse != null)
 755         {
 756
 757                 int count = pResponse->record_num;
 758                 if (pSettingsManager->__pSettingsEventListener != null)
 759                 {
 760                         for (int index = 0; index < count; index++)
 761                         {
 762                                 //notify event listeners
 763                                 bool isCallWaitingEnabled = (pResponse->record[index].Status == TAPI_SS_STATUS_ACTIVE);
 764                                 pSettingsManager->NotifyWaitingEventListeners(SET_CALLWAITING_RESPONSE, isCallSuccessful, isCallWaitingEnabled);
 765                         }
 766                 }
 767         }
 768 }
 769
 770 int
 771 SettingsManager::GetCallWaitingStatus(void)
 772 {
 773         int errorCode = ERROR_NONE;
 774         TryReturn(__pTapiHandle != null, ERROR_TAPI_INIT_FAILED,"Telephony initialization failed");
 775
 776         int retStatus = tel_get_ss_waiting_status(__pTapiHandle, TAPI_SS_CLASS_VOICE, &HandleGetWaitingResponse, this);
 777         if (retStatus != TAPI_API_SUCCESS)
 778         {
 779                 errorCode = ERROR_TAPI_ERROR;
 780         }
 781
 782         return errorCode;
 783 }
 784
 785 void
 786 SettingsManager::HandleGetWaitingResponse(TapiHandle* pHandle, int result, void* pData, void* pUserData)
 787 {
 788         TelSsWaitingResp_t* pResponse = (TelSsWaitingResp_t*) pData;
 789         SettingsManager* pSettingsManager = (SettingsManager*) pUserData;
 790         if (pResponse != null)
 791         {
 792                 bool isCallSuccessful = false;
 793                 if (result == TAPI_SS_SUCCESS)
 794                 {
 795                         isCallSuccessful = true;
 796                 }
 797                 int count = pResponse->record_num;
 798                 if (pSettingsManager->__pSettingsEventListener != null)
 799                 {
 800                         for (int index = 0; index < count; index++)
 801                         {
 802                                 //notify event listeners
 803                                 bool isCallWaitingEnabled = (pResponse->record[index].Status == TAPI_SS_STATUS_ACTIVE);
 804                                 pSettingsManager->NotifyWaitingEventListeners(GET_CALLWAITING_RESPONSE, isCallSuccessful, isCallWaitingEnabled);
 805                         }
 806                 }
 807         }
 808 }
 809
 810 IMapT<int,String>*
 811 SettingsManager::GetRejectMessageListN(void)
 812 {
 813         int messagesCount;
 814         char* pMessage = null;
 815         HashMapT<int, String> *pMessageMap = null;
 816
 817         int retval = vconf_get_int(VCONFKEY_CISSAPPL_REJECT_CALL_MSG_INT, &messagesCount);
 818         if (retval == 0 && messagesCount > 0)
 819         {
 820                 pMessageMap = new (std::nothrow) HashMapT<int, String>();
 821                 pMessageMap->Construct(messagesCount);
 822                 for (int index = 0; index < messagesCount; index++)
 823                 {
 824                         int keyForMsg = index;
 825                         pMessage = null;
 826                         switch (index)
 827                         {
 828                         case 0:
 829                         {
 830                                 pMessage = vconf_get_str( VCONFKEY_CISSAPPL_USER_CREATE_MSG1_STR);
 831                         }
 832                                 break;
 833
 834                         case 1:
 835                         {
 836                                 pMessage = vconf_get_str( VCONFKEY_CISSAPPL_USER_CREATE_MSG2_STR);
 837                         }
 838                                 break;
 839
 840                         case 2:
 841                         {
 842                                 pMessage = vconf_get_str( VCONFKEY_CISSAPPL_USER_CREATE_MSG3_STR);
 843                         }
 844                                 break;
 845
 846                         case 3:
 847                         {
 848                                 pMessage = vconf_get_str( VCONFKEY_CISSAPPL_USER_CREATE_MSG4_STR);
 849                         }
 850                                 break;
 851
 852                         case 4:
 853                         {
 854                                 pMessage = vconf_get_str( VCONFKEY_CISSAPPL_USER_CREATE_MSG5_STR);
 855                         }
 856                                 break;
 857
 858                         case 5:
 859                         {
 860                                 pMessage = vconf_get_str( VCONFKEY_CISSAPPL_USER_CREATE_MSG6_STR);
 861                         }
 862                                 break;
 863
 864                         default:
 865                                 break;
 866                         }
 867
 868                         //Chk if this is allowed outside the call settings library
 869                         if ((pMessage != null) && (String(pMessage).IsEmpty() == false))
 870                         {
 871                                 bindtextdomain("ug-setting-call-efl", "/usr/ug/res/locale");
 872                                 String *pMessageStr = new (std::nothrow) String();
 873                                 pMessageStr->Append(dgettext("ug-setting-call-efl", pMessage));
 874                                 pMessageMap->Add(keyForMsg, *pMessageStr);
 875                         }
 876                 }
 877         }
 878         return pMessageMap;
 879 }
 880
 881 result
 882 SettingsManager::SetRejectMessage(int messageIndex, const String& rejectMessage)
 883 {
 884         result r = E_FAILURE;
 885         int messagesCount = 0;
 886         vconf_get_int(VCONFKEY_CISSAPPL_REJECT_CALL_MSG_INT, &messagesCount);
 887         //convert to char*
 888         const wchar_t* pRejectMessage = rejectMessage.GetPointer();
 889         int len = (rejectMessage.GetLength()*sizeof(wchar_t));
 890         char* pMessageToBeSet = new (std::nothrow) char[len + 1];
 891         memset(pMessageToBeSet, 0, (len + 1) * sizeof(char));
 892         wcstombs(pMessageToBeSet, pRejectMessage, len);
 893         //save to vconf
 894         int retval = -1;
 895
 896         switch (messageIndex)
 897         {
 898         case 0:
 899         {
 900                 retval = vconf_set_str(VCONFKEY_CISSAPPL_USER_CREATE_MSG1_STR, pMessageToBeSet);
 901         }
 902         break;
 903
 904         case 1:
 905         {
 906                 retval = vconf_set_str(VCONFKEY_CISSAPPL_USER_CREATE_MSG2_STR, pMessageToBeSet);
 907         }
 908         break;
 909
 910         case 2:
 911         {
 912                 retval = vconf_set_str(VCONFKEY_CISSAPPL_USER_CREATE_MSG3_STR, pMessageToBeSet);
 913         }
 914         break;
 915
 916         case 3:
 917         {
 918                 retval = vconf_set_str(VCONFKEY_CISSAPPL_USER_CREATE_MSG4_STR, pMessageToBeSet);
 919         }
 920         break;
 921
 922         case 4:
 923         {
 924                 retval = vconf_set_str(VCONFKEY_CISSAPPL_USER_CREATE_MSG5_STR, pMessageToBeSet);
 925         }
 926         break;
 927
 928         case 5:
 929         {
 930                 retval = vconf_set_str(VCONFKEY_CISSAPPL_USER_CREATE_MSG6_STR, pMessageToBeSet);
 931         }
 932         break;
 933
 934         default:
 935         break;
 936         }
 937         delete []pMessageToBeSet;
 938         pMessageToBeSet = null;
 939
 940         if (retval == 0)
 941         {
 942                 //increment the count only in case of new addition
 943                 if (messagesCount < 6 && messageIndex >= messagesCount)
 944                 {
 945                         messagesCount++;
 946                 }
 947                 vconf_set_int(VCONFKEY_CISSAPPL_REJECT_CALL_MSG_INT, messagesCount);
 948                 r = E_SUCCESS;
 949         }
 950         return r;
 951 }
 952
 953 result
 954 SettingsManager::RemoveRejectMessage(const IListT<int>& deleteKeyList)
 955 {
 956         result r = E_FAILURE;
 957         int retval = -1;
 958         int newMsgCount = 0;
 959         //Fetch old message count
 960         int oldMsgCount = 0;
 961         vconf_get_int(VCONFKEY_CISSAPPL_REJECT_CALL_MSG_INT, &oldMsgCount);
 962         //fetch old messages
 963         IMapT<int,String> *pRejectMsgMap = GetRejectMessageListN();
 964         if(pRejectMsgMap != null)
 965         {
 966                 //First,remove all messages from vconf
 967                 for (int index = 0; index < oldMsgCount; index++)
 968                 {
 969                         switch (index)
 970                         {
 971                         case 0:
 972                                 retval = vconf_set_str(VCONFKEY_CISSAPPL_USER_CREATE_MSG1_STR,"");
 973                                 break;
 974
 975                         case 1:
 976                                 retval = vconf_set_str(VCONFKEY_CISSAPPL_USER_CREATE_MSG2_STR,"");
 977                                 break;
 978
 979                         case 2:
 980                                 retval = vconf_set_str(VCONFKEY_CISSAPPL_USER_CREATE_MSG3_STR,"");
 981                                 break;
 982
 983                         case 3:
 984                                 retval = vconf_set_str(VCONFKEY_CISSAPPL_USER_CREATE_MSG4_STR,"");
 985                                 break;
 986
 987                         case 4:
 988                                 retval = vconf_set_str(VCONFKEY_CISSAPPL_USER_CREATE_MSG5_STR,"");
 989                                 break;
 990
 991                         case 5:
 992                                 retval = vconf_set_str(VCONFKEY_CISSAPPL_USER_CREATE_MSG6_STR,"");
 993                                 break;
 994                         }
 995                 }
 996
 997                 //Check if all messages are deleted
 998                 if(oldMsgCount == deleteKeyList.GetCount())
 999                 {
1000                         vconf_set_int(VCONFKEY_CISSAPPL_REJECT_CALL_MSG_INT, 0);
1001                         delete pRejectMsgMap;
1002                         return E_SUCCESS;
1003                 }
1004
1005                 //Second, delete messages to be deleted from fetched old Message map
1006                 for (int index = 0; index < deleteKeyList.GetCount(); index++)
1007                 {
1008                         int keyForMsg = -1;
1009                         if (deleteKeyList.GetAt(index, keyForMsg) == E_SUCCESS)
1010                         {
1011                                 pRejectMsgMap->Remove(keyForMsg);
1012                         }
1013                 }
1014
1015                 //Third, reset remaining message in vconf with ordered keys
1016                 IListT<String> *pRejectMsgList = pRejectMsgMap->GetValuesN();
1017                 newMsgCount = pRejectMsgList->GetCount();
1018                 for (int index = 0; index < newMsgCount; index++)
1019                 {
1020                         String msg;
1021                         pRejectMsgList->GetAt(index,msg);
1022                         //convert to char*
1023                         const wchar_t* pMsgPtr = msg.GetPointer();
1024                         int len = msg.GetLength()*sizeof(wchar_t);
1025                         char* pMessageToBeSet = new (std::nothrow) char[len + 1];
1026                         memset(pMessageToBeSet, 0, (len + 1) * sizeof(char));
1027                         wcstombs(pMessageToBeSet, pMsgPtr, len);
1028                         switch (index)
1029                         {
1030                         case 0:
1031                         {
1032                                 retval = vconf_set_str(VCONFKEY_CISSAPPL_USER_CREATE_MSG1_STR, pMessageToBeSet);
1033                         }
1034                         break;
1035
1036                         case 1:
1037                         {
1038                                 retval = vconf_set_str(VCONFKEY_CISSAPPL_USER_CREATE_MSG2_STR, pMessageToBeSet);
1039                         }
1040                         break;
1041
1042                         case 2:
1043                         {
1044                                 retval = vconf_set_str(VCONFKEY_CISSAPPL_USER_CREATE_MSG3_STR, pMessageToBeSet);
1045                         }
1046                         break;
1047
1048                         case 3:
1049                         {
1050                                 retval = vconf_set_str(VCONFKEY_CISSAPPL_USER_CREATE_MSG4_STR, pMessageToBeSet);
1051                         }
1052                         break;
1053
1054                         case 4:
1055                         {
1056                                 retval = vconf_set_str(VCONFKEY_CISSAPPL_USER_CREATE_MSG5_STR, pMessageToBeSet);
1057                         }
1058                         break;
1059
1060                         case 5:
1061                         {
1062                                 retval = vconf_set_str(VCONFKEY_CISSAPPL_USER_CREATE_MSG6_STR, pMessageToBeSet);
1063                         }
1064                         break;
1065
1066                         default:
1067                         break;
1068                         }
1069                         delete []pMessageToBeSet;
1070                         pMessageToBeSet = null;
1071                 }
1072                 delete pRejectMsgMap;
1073                 pRejectMsgMap = null;
1074         }
1075
1076         //todo: retVal from vconf_unset is always -1. to be checked
1077 //      if (retval == 0)
1078         {
1079                 //Update message count in vconf
1080                 vconf_set_int(VCONFKEY_CISSAPPL_REJECT_CALL_MSG_INT, newMsgCount);
1081                 r = E_SUCCESS;
1082         }
1083
1084         return r;
1085 }
1086
1087 IList*
1088 SettingsManager::GetPrefixDialListN(void)
1089 {
1090         int phoneNumberCount;
1091         char* pPhoneNumber = null;
1092         ArrayList* pPhoneNumberList = null;
1093
1094         int retval = vconf_get_int(VCONFKEY_CISSAPPL_PREFIX_DIAL_INT, &phoneNumberCount);
1095         if (retval == 0)
1096         {
1097                 pPhoneNumberList = new (std::nothrow) ArrayList();
1098                 for (int index = 0; index < phoneNumberCount; index++)
1099                 {
1100                         String* phoneNumberStr = new (std::nothrow) String();
1101                         switch (index)
1102                         {
1103                         case 0:
1104                         {
1105                                 pPhoneNumber = vconf_get_str(VCONFKEY_CISSAPPL_PREFIX_DIAL_NUM1_STR);
1106                         }
1107                         break;
1108
1109                         case 1:
1110                         {
1111                                 pPhoneNumber = vconf_get_str(VCONFKEY_CISSAPPL_PREFIX_DIAL_NUM2_STR);
1112                         }
1113                         break;
1114
1115                         case 2:
1116                         {
1117                                 pPhoneNumber = vconf_get_str(VCONFKEY_CISSAPPL_PREFIX_DIAL_NUM3_STR);
1118                         }
1119                         break;
1120
1121                         case 3:
1122                         {
1123                                 pPhoneNumber = vconf_get_str(VCONFKEY_CISSAPPL_PREFIX_DIAL_NUM4_STR);
1124                         }
1125                         break;
1126
1127                         case 4:
1128                         {
1129                                 pPhoneNumber = vconf_get_str(VCONFKEY_CISSAPPL_PREFIX_DIAL_NUM5_STR);
1130                         }
1131                         break;
1132
1133                         default:
1134                         {
1135                                 delete pPhoneNumberList;
1136                                 pPhoneNumberList = null;
1137                                 return null;
1138                         }
1139                         break;
1140                         }
1141                         phoneNumberStr->Append(pPhoneNumber);
1142                         pPhoneNumberList->Add(*phoneNumberStr);
1143                 }
1144         }
1145         else
1146         {
1147                 return null;
1148         }
1149         return pPhoneNumberList;
1150 }
1151
1152 result
1153 SettingsManager::SetPrefixDialNumber(int phoneNumberIndex, const String& phoneNumber)
1154 {
1155         result r = E_FAILURE;
1156         int phoneNumberCount = 0;
1157
1158         int retval = -1;
1159         const wchar_t* pRejectMessage = phoneNumber.GetPointer();
1160         int len = phoneNumber.GetLength();
1161         char* pTmpPhonePtr = new (std::nothrow) char[len + 1];
1162         memset(pTmpPhonePtr, 0, (len + 1) * sizeof(char));
1163         wcstombs(pTmpPhonePtr, pRejectMessage, len);
1164         char* pNumberToBeSet = new (std::nothrow) char[len + 1];
1165         memset(pNumberToBeSet, 0, (len + 1) * sizeof(char));
1166         strncpy(pNumberToBeSet, pTmpPhonePtr, len);
1167         delete []pTmpPhonePtr;
1168         pTmpPhonePtr = null;
1169         vconf_get_int(VCONFKEY_CISSAPPL_PREFIX_DIAL_INT, &phoneNumberCount);
1170         switch (phoneNumberIndex)
1171         {
1172         case 0:
1173         {
1174                 retval = vconf_set_str(VCONFKEY_CISSAPPL_PREFIX_DIAL_NUM1_STR, pNumberToBeSet);
1175         }
1176         break;
1177
1178         case 1:
1179         {
1180                 retval = vconf_set_str(VCONFKEY_CISSAPPL_PREFIX_DIAL_NUM2_STR, pNumberToBeSet);
1181         }
1182         break;
1183
1184         case 2:
1185         {
1186                 retval = vconf_set_str(VCONFKEY_CISSAPPL_PREFIX_DIAL_NUM3_STR, pNumberToBeSet);
1187         }
1188         break;
1189
1190         case 3:
1191         {
1192                 retval = vconf_set_str(VCONFKEY_CISSAPPL_PREFIX_DIAL_NUM4_STR, pNumberToBeSet);
1193         }
1194         break;
1195
1196         case 4:
1197         {
1198                 retval = vconf_set_str(VCONFKEY_CISSAPPL_PREFIX_DIAL_NUM5_STR, pNumberToBeSet);
1199         }
1200         break;
1201
1202         default:
1203         {
1204                 delete []pNumberToBeSet;
1205                 pNumberToBeSet = null;
1206                 return r;
1207         }
1208         break;
1209         }
1210
1211         delete []pNumberToBeSet;
1212         pNumberToBeSet = null;
1213
1214         if (retval == 0)
1215         {
1216                 if (phoneNumberCount < 5)
1217                 {
1218                         phoneNumberCount++;
1219                 }
1220                 vconf_set_int(VCONFKEY_CISSAPPL_PREFIX_DIAL_INT, phoneNumberCount);
1221                 r = E_SUCCESS;
1222         }
1223
1224         return r;
1225 }
1226
1227 result
1228 SettingsManager::GetPrefixDialNumberAtIndex(int phoneNumberIndex, String& phoneNumber)
1229 {
1230         result r = E_FAILURE;
1231
1232         int phoneNumberCount = 0;
1233         vconf_get_int(VCONFKEY_CISSAPPL_PREFIX_DIAL_INT, &phoneNumberCount);
1234
1235         //check valid index
1236         if(phoneNumberCount > 0 && phoneNumberIndex < phoneNumberCount)
1237         {
1238                 char* pPhoneNumber = null;
1239                 switch (phoneNumberIndex)
1240                 {
1241                 case 0:
1242                 {
1243                         pPhoneNumber = vconf_get_str(VCONFKEY_CISSAPPL_PREFIX_DIAL_NUM1_STR);
1244                 }
1245                 break;
1246
1247                 case 1:
1248                 {
1249                         pPhoneNumber = vconf_get_str(VCONFKEY_CISSAPPL_PREFIX_DIAL_NUM2_STR);
1250                 }
1251                 break;
1252
1253                 case 2:
1254                 {
1255                         pPhoneNumber = vconf_get_str(VCONFKEY_CISSAPPL_PREFIX_DIAL_NUM3_STR);
1256                 }
1257                 break;
1258
1259                 case 3:
1260                 {
1261                         pPhoneNumber = vconf_get_str(VCONFKEY_CISSAPPL_PREFIX_DIAL_NUM4_STR);
1262                 }
1263                 break;
1264
1265                 case 4:
1266                 {
1267                         pPhoneNumber = vconf_get_str(VCONFKEY_CISSAPPL_PREFIX_DIAL_NUM5_STR);
1268                 }
1269                 break;
1270
1271                 default:
1272                 break;
1273                 }
1274
1275                 if(pPhoneNumber != null)
1276                 {
1277                         r = phoneNumber.Append(pPhoneNumber);
1278                 }
1279         }
1280         return r;
1281 }
1282
1283 result
1284 SettingsManager::SetPrefixDialingStatus(bool enablePrefixDialing)
1285 {
1286         result r = E_FAILURE;
1287         int retVal = vconf_set_bool(VCONFKEY_CISSAPPL_PREFIX_DIAL_BOOL, enablePrefixDialing);
1288         if (retVal == 0)
1289         {
1290                 r = E_SUCCESS;
1291         }
1292         return r;
1293 }
1294
1295 result
1296 SettingsManager::SetActivePrefixDialingValue(int prefixDialIndex)
1297 {
1298         result r = E_FAILURE;
1299         int retVal = vconf_set_int(VCONFKEY_CISSAPPL_PREFIX_DIAL_VALUE_INT, prefixDialIndex);
1300         if (retVal == 0)
1301         {
1302                 r = E_SUCCESS;
1303         }
1304         return r;
1305 }
1306
1307 result
1308 SettingsManager::GetActivePrefixDialingValue(int& prefixDialIndex)
1309 {
1310         result r = E_FAILURE;
1311         int indexPos = -1;
1312         int retVal = vconf_get_int(VCONFKEY_CISSAPPL_PREFIX_DIAL_VALUE_INT, &indexPos);
1313         if (retVal == 0)
1314         {
1315                 prefixDialIndex = indexPos;
1316                 r = E_SUCCESS;
1317         }
1318         return r;
1319 }
1320
1321 bool
1322 SettingsManager::GetPrefixDialingStatus(void)
1323 {
1324         int isPrefixDialingEnabled = -1;
1325
1326         vconf_get_bool(VCONFKEY_CISSAPPL_PREFIX_DIAL_BOOL, &isPrefixDialingEnabled);
1327
1328         bool retVal = isPrefixDialingEnabled;
1329         return retVal;
1330 }
1331
1332 result
1333 SettingsManager::SetVideoCallImagePath(const String& imagePath)
1334 {
1335         result r = E_FAILURE;
1336         const wchar_t* pRejectMessage = imagePath.GetPointer();
1337         int len = imagePath.GetLength();
1338         char* pTmpPath = new (std::nothrow) char[len + 1];
1339         memset(pTmpPath, 0, (len + 1) * sizeof(char));
1340         wcstombs(pTmpPath, pRejectMessage, len);
1341         char* pPathToBeSet = new (std::nothrow) char[len + 1];
1342         memset(pPathToBeSet, 0, (len + 1) * sizeof(char));
1343         strncpy(pPathToBeSet, pTmpPath, len);
1344         int retVal = vconf_set_str(VCONFKEY_CISSAPPL_VIDEO_IMAGE_PATH_STR, pPathToBeSet);
1345         if (retVal == 0)
1346         {
1347                 r = E_SUCCESS;
1348         }
1349         delete []pTmpPath;
1350         pTmpPath = null;
1351         delete []pPathToBeSet;
1352         pPathToBeSet = null;
1353         return r;
1354 }
1355
1356 result
1357 SettingsManager::GetVideoCallImagePath(String& imagePath)
1358 {
1359         result r = E_FAILURE;
1360         char* pVideoImagePath = null;
1361         pVideoImagePath = vconf_get_str(VCONFKEY_CISSAPPL_VIDEO_IMAGE_PATH_STR);
1362         if (pVideoImagePath != null)
1363         {
1364                 imagePath.Clear();
1365                 imagePath.Append(pVideoImagePath);
1366                 r = E_SUCCESS;
1367         }
1368         return r;
1369 }
1370
1371 result
1372 SettingsManager::SetCallLineIdentity(CallLineIdentity identity)
1373 {
1374         result r = E_FAILURE;
1375         int retVal = vconf_set_int(VCONFKEY_CISSAPPL_SHOW_MY_NUMBER_INT, identity);
1376         if (retVal == 0)
1377         {
1378                 r = E_SUCCESS;
1379         }
1380         return r;
1381 }
1382
1383 result
1384 SettingsManager::GetCallLineIdentity(CallLineIdentity& identity)
1385 {
1386         result r = E_FAILURE;
1387         int lineIdentity = -1;
1388         int retVal = vconf_get_int(VCONFKEY_CISSAPPL_SHOW_MY_NUMBER_INT, &lineIdentity);
1389         if (retVal == 0)
1390         {
1391                 identity = (CallLineIdentity) lineIdentity;
1392                 r = E_SUCCESS;
1393         }
1394         return r;
1395 }
1396
1397 result
1398 SettingsManager::AddToCallRejectList(const String& phoneNumber, CallRejectMatchCondition rejectCondition, bool isActivated)
1399 {
1400         //construct CallRejectInfo.
1401         CallRejectInfo rejInfo;
1402         rejInfo.phoneNumber = phoneNumber;
1403         rejInfo.rejectCondition = rejectCondition;
1404         rejInfo.isActivated = isActivated;
1405
1406         //Fetch call reject list
1407         IListT<CallRejectInfo>* pRejNumbersList = GetCallRejectList();
1408         //Check if this is not already present in database.
1409         bool isDuplicate = false;
1410         if (pRejNumbersList != null)
1411         {
1412                 IEnumeratorT<CallRejectInfo>* pRejectEnum = pRejNumbersList->GetEnumeratorN();
1413                 if (pRejectEnum != null)
1414                 {
1415                         while (pRejectEnum->MoveNext() == E_SUCCESS)
1416                         {
1417                                 CallRejectInfo fetchedInfo;
1418                                 if (( pRejectEnum->GetCurrent(fetchedInfo) == E_SUCCESS) && (fetchedInfo == rejInfo))
1419                                 {
1420                                         isDuplicate = true;
1421                                 }
1422                         }
1423                         delete pRejectEnum;
1424                 }
1425                 delete pRejNumbersList;
1426         }
1427
1428         result r = E_OBJ_ALREADY_EXIST;
1429         if (isDuplicate == false)
1430         {
1431                 r = __pCallSettingDataService->AddCallRejectInfoToDatabase(&rejInfo);
1432         }
1433         return r;
1434 }
1435
1436 IListT<CallRejectInfo>*
1437 SettingsManager::GetCallRejectList(void)
1438 {
1439         int rejectCount = 0;
1440         __pCallSettingDataService->GetCallRejectCount(rejectCount);
1441
1442         if (rejectCount > 0)
1443         {
1444                 ArrayListT<CallRejectInfo>* pCallRejectList = new (std::nothrow) ArrayListT<CallRejectInfo>();
1445                 pCallRejectList->Construct(rejectCount);
1446                 __pCallSettingDataService->GetAllCallRejectInfoFromDatabaseN(*pCallRejectList);
1447                 return pCallRejectList;
1448         }
1449         return null;
1450 }
1451
1452 result
1453 SettingsManager::UpdateCallRejectRow(int rowId, const String& phoneNumber, bool activate, CallRejectMatchCondition rejectCondition)
1454 {
1455         result r = E_FAILURE;
1456         CallRejectInfo* rejInfo = new (std::nothrow) CallRejectInfo();
1457         rejInfo->rowId = rowId;
1458         rejInfo->phoneNumber.Append(phoneNumber);
1459         rejInfo->rejectCondition = rejectCondition;
1460         rejInfo->isActivated = activate;
1461         r = __pCallSettingDataService->UpdateCallRejectInfoDatabase(rowId,rejInfo);
1462         delete rejInfo;
1463         return r;
1464 }
1465
1466 result
1467 SettingsManager::RemoveCallRejectRow(int rowId)
1468 {
1469         return __pCallSettingDataService->DeleteCallRejectInfoFromDatabase(rowId);
1470 }
1471
1472 result
1473 SettingsManager::SetUnknownRejectStatus(bool activate)
1474 {
1475         result r = E_FAILURE;
1476         int retVal = vconf_set_bool(VCONFKEY_CISSAPPL_AUTO_REJECT_UNKNOWN_BOOL, activate);
1477         if (retVal == 0)
1478         {
1479                 r = E_SUCCESS;
1480         }
1481         return r;
1482 }
1483
1484 bool
1485 SettingsManager::IsCallToBeRejected(String& phoneNumber)
1486 {
1487         return __pCallSettingDataService->IsCallToBeRejected(phoneNumber);
1488 }
1489
1490 bool
1491 SettingsManager::GetUnknownRejectStatus(void)
1492 {
1493         int unknownRejectStatus = -1;
1494
1495         vconf_get_bool(VCONFKEY_CISSAPPL_AUTO_REJECT_UNKNOWN_BOOL, &unknownRejectStatus);
1496
1497         bool retVal = unknownRejectStatus;
1498         return retVal;
1499 }
1500
1501 result
1502 SettingsManager::SetCallAlertStatus(CallAlertStatus callAlertStatus)
1503 {
1504         result r = E_FAILURE;
1505         int retVal = vconf_set_int(VCONFKEY_CISSAPPL_ALERT_ON_CALL_INT, callAlertStatus);
1506         if (retVal == 0)
1507         {
1508                 r = E_SUCCESS;
1509         }
1510         return r;
1511 }
1512
1513 result
1514 SettingsManager::GetCallAlertStatus(CallAlertStatus& callAlertStatus)
1515 {
1516         result r = E_FAILURE;
1517         int alertStatus = -1;
1518         int retVal = vconf_get_int(VCONFKEY_CISSAPPL_ALERT_ON_CALL_INT, &alertStatus);
1519         if (retVal == 0)
1520         {
1521                 callAlertStatus = (CallAlertStatus) alertStatus;
1522                 r = E_SUCCESS;
1523         }
1524         return r;
1525 }
1526
1527 result
1528 SettingsManager::SetCallConnectToneStatus(bool activate)
1529 {
1530         result r = E_FAILURE;
1531         int retVal = vconf_set_bool(VCONFKEY_CISSAPPL_CALL_CONNECT_TONE_BOOL, activate);
1532         if (retVal == 0)
1533         {
1534                 r = E_SUCCESS;
1535         }
1536         return r;
1537 }
1538
1539 bool
1540 SettingsManager::GetCallConnectToneStatus(void)
1541 {
1542         int unknownRejectStatus = -1;
1543
1544         vconf_get_bool(VCONFKEY_CISSAPPL_CALL_CONNECT_TONE_BOOL, &unknownRejectStatus);
1545
1546         bool retVal = unknownRejectStatus;
1547         return retVal;
1548 }
1549
1550 result
1551 SettingsManager::SetMinuteMinderToneStatus(bool activate)
1552 {
1553         result r = E_FAILURE;
1554         int retVal = vconf_set_bool(VCONFKEY_CISSAPPL_MINUTE_MINDER_BOOL, activate);
1555         if (retVal == 0)
1556         {
1557                 r = E_SUCCESS;
1558         }
1559         return r;
1560 }
1561
1562 bool
1563 SettingsManager::GetMinuteMinderToneStatus(void)
1564 {
1565         int unknownRejectStatus = -1;
1566
1567         vconf_get_bool(VCONFKEY_CISSAPPL_MINUTE_MINDER_BOOL, &unknownRejectStatus);
1568
1569         bool retVal = unknownRejectStatus;
1570         return retVal;
1571 }
1572
1573 result
1574 SettingsManager::SetCallEndToneStatus(bool activate)
1575 {
1576         result r = E_FAILURE;
1577         int retVal = vconf_set_bool(VCONFKEY_CISSAPPL_CALL_END_TONE_BOOL, activate);
1578         if (retVal == 0)
1579         {
1580                 r = E_SUCCESS;
1581         }
1582         return r;
1583 }
1584
1585 bool
1586 SettingsManager::GetCallEndToneStatus(void)
1587 {
1588         int unknownRejectStatus = -1;
1589
1590         vconf_get_bool(VCONFKEY_CISSAPPL_CALL_END_TONE_BOOL, &unknownRejectStatus);
1591
1592         bool retVal = unknownRejectStatus;
1593         return retVal;
1594 }
1595
1596 result
1597 SettingsManager::SetSpeedDialMapping(const String& contactId, int numberToMap)
1598 {
1599         result r = E_FAILURE;
1600         SpeedDialInfo mappingInfo;;
1601         mappingInfo.keyMapping = numberToMap;
1602         mappingInfo.contactId = contactId;
1603         r = __pCallSettingDataService->AddSpeedDialInfoToDatabase(&mappingInfo);
1604         return r;
1605 }
1606
1607 IMapT<int,SpeedDialInfo>*
1608 SettingsManager::GetSpeedDialMappingN(void)
1609 {
1610         return (__pCallSettingDataService->GetAllSpeedDialInfoMapFromDatabaseN());
1611 }
1612
1613 result
1614 SettingsManager::RemoveSpeedDialMapping(int rowId)
1615 {
1616         return __pCallSettingDataService->DeleteSpeedDialInfoFromDatabase(rowId);
1617 }
1618
1619 result
1620 SettingsManager::UpdateSpeedDialMapping(int rowId, const String& contactId, int numberToMap)
1621 {
1622         result r = E_FAILURE;
1623         SpeedDialInfo* mappingInfo = new (std::nothrow) SpeedDialInfo();
1624         mappingInfo->rowId = rowId;
1625         mappingInfo->contactId.Append(contactId);
1626         mappingInfo->keyMapping = numberToMap;
1627         r = __pCallSettingDataService->UpdateSpeedDialInfoDatabase(rowId,mappingInfo);
1628         delete mappingInfo;
1629         return r;
1630 }
1631
1632 String*
1633 SettingsManager::GetMappedSpeedDialNumberN(int aIndex)
1634 {
1635         String* contactNumber = null;
1636
1637         //Fetch contactId for mapped speed dial
1638         String* contactId = __pCallSettingDataService->GetSpeedDialContactN(aIndex);
1639         if(contactId != null && contactId->IsEmpty() == false)
1640         {
1641                 RecordId recordId = INVALID_RECORD_ID;
1642                 Integer::Parse(*contactId, recordId);
1643                 //check if recordId is correct
1644                 if (recordId != Tizen::Social::INVALID_RECORD_ID)
1645                 {
1646                         AddressbookManager* pAddressbookManager = AddressbookManager::GetInstance();
1647                         Addressbook* pAddressbook = pAddressbookManager->GetAddressbookN(DEFAULT_ADDRESSBOOK_ID);
1648                         if (pAddressbook != null)
1649                         {
1650                                 Contact* pMappedContact = pAddressbook->GetContactN(recordId);
1651                                 if (pMappedContact != null)
1652                                 {
1653                                         IList* pPhoneNumberList = pMappedContact->GetValuesN(CONTACT_MPROPERTY_ID_PHONE_NUMBERS);
1654                                         if (pPhoneNumberList != null)
1655                                         {
1656                                                 PhoneNumber* pPhoneNumber = static_cast<PhoneNumber*>(pPhoneNumberList->GetAt(0));
1657                                                 if(pPhoneNumber != null)
1658                                                 {
1659                                                         contactNumber = new (std::nothrow) String(pPhoneNumber->GetPhoneNumber());
1660                                                 }
1661                                                 pPhoneNumberList->RemoveAll(true);
1662                                                 delete pPhoneNumberList;
1663                                         }
1664                                         delete pMappedContact;
1665                                 }
1666                                 delete pAddressbook;
1667                         }
1668                 }
1669         }
1670         delete contactId;
1671         contactId = null;
1672         return contactNumber;
1673 }
1674
1675 Contact*
1676 SettingsManager::FetchContactDetailsN(const String& contactId)
1677 {
1678         Contact* pFetchedContact = null;
1679
1680         RecordId recordId = INVALID_RECORD_ID;
1681         Integer::Parse(contactId, recordId);
1682         //check if recordId is correct
1683         if (recordId != Tizen::Social::INVALID_RECORD_ID)
1684         {
1685                 AddressbookManager* pAddressbookManager = AddressbookManager::GetInstance();
1686                 Addressbook* pAddressbook = pAddressbookManager->GetAddressbookN(DEFAULT_ADDRESSBOOK_ID);
1687                 if (pAddressbook != null)
1688                 {
1689                         pFetchedContact = pAddressbook->GetContactN(recordId);
1690                         delete pAddressbook;
1691                 }
1692         }
1693         return pFetchedContact;
1694 }
1695
1696 result
1697 SettingsManager::SetCallState(CallState callState)
1698 {
1699         AppLogDebug("Enter %d",callState);
1700         result r = E_FAILURE;
1701         int retVal = vconf_set_int(VCONFKEY_CALL_STATE, callState);
1702         if (retVal == 0)
1703         {
1704                 r = E_SUCCESS;
1705         }
1706         return r;
1707 }
1708
1709 result
1710 SettingsManager::GetCallState(CallState& callState)
1711 {
1712         AppLogDebug("Enter %d",callState);
1713         int Status = 0;
1714         result r = E_FAILURE;
1715         int retVal = vconf_get_int(VCONFKEY_CALL_STATE, &Status);
1716         if (retVal == 0)
1717         {
1718                 callState = (CallState) Status;
1719                 r = E_SUCCESS;
1720         }
1721         return r;
1722 }
1723
1724 result
1725 SettingsManager::EnableCallAnsweringKey(bool activate)
1726 {
1727         result r = E_FAILURE;
1728         int retVal = vconf_set_bool(VCONFKEY_CISSAPPL_ANSWERING_KEY_BOOL, activate);
1729         if (retVal == 0)
1730         {
1731                 r = E_SUCCESS;
1732         }
1733         return r;
1734 }
1735
1736 bool
1737 SettingsManager::IsCallAnsweringKeyEnabled(void)
1738 {
1739         int isAcceptCallByHomeKeyEnabled = -1;
1740         //read vconf settings
1741         vconf_get_bool(VCONFKEY_CISSAPPL_ANSWERING_KEY_BOOL, &isAcceptCallByHomeKeyEnabled);
1742         return (bool)isAcceptCallByHomeKeyEnabled;
1743 }
1744
1745 result
1746 SettingsManager::EnableCallEndingKey(bool activate)
1747 {
1748         result r = E_FAILURE;
1749         int retVal = vconf_set_bool(VCONFKEY_CISSAPPL_POWER_KEY_ENDS_CALL_BOOL, activate);
1750         if (retVal == 0)
1751         {
1752                 r = E_SUCCESS;
1753         }
1754         return r;
1755 }
1756
1757 bool
1758 SettingsManager::IsCallEndingKeyEnabled(void)
1759 {
1760         int isEndCallByPowerKeyEnabled = -1;
1761         //read vconf settings
1762         vconf_get_bool(VCONFKEY_CISSAPPL_POWER_KEY_ENDS_CALL_BOOL, &isEndCallByPowerKeyEnabled);
1763         return (bool)isEndCallByPowerKeyEnabled;
1764 }
1765
1766 result
1767 SettingsManager::EnableOutgoingCallWhenLocked(bool activate)
1768 {
1769         result r = E_FAILURE;
1770
1771         int enableOutgoingCall = 1;
1772         if (activate == true)
1773         {
1774                 //0 : Even when device locked
1775                 //1 : Only when device unlocked
1776                 enableOutgoingCall = 0;
1777         }
1778         int retVal = vconf_set_bool(VCONFKEY_CISSAPPL_OUTGOING_CALL_CONDITIONS_INT, enableOutgoingCall);
1779         if (retVal == 0)
1780         {
1781                 r = E_SUCCESS;
1782         }
1783         return r;
1784 }
1785
1786 bool
1787 SettingsManager::IsOutgoingCallEnabledWhenLocked(void)
1788 {
1789         //read vconf settings
1790         int isOutgoingCallPossibleWhenLocked = -1;
1791         vconf_get_bool(VCONFKEY_CISSAPPL_OUTGOING_CALL_CONDITIONS_INT, &isOutgoingCallPossibleWhenLocked);
1792         if (isOutgoingCallPossibleWhenLocked == 0)
1793         {
1794                 //0 : Even when device locked
1795                 return true;
1796         }
1797         //1 : Only when device unlocked
1798         return false;
1799 }
1800
1801 void
1802 SettingsManager::AddSystemEventListener(void)
1803 {
1804         Tizen::System::SettingInfo::AddSettingEventListener(*this);
1805 }
1806
1807 void
1808 SettingsManager::RemoveSystemEventListener(void)
1809 {
1810         Tizen::System::SettingInfo::RemoveSettingEventListener(*this);
1811 }
1812
1813 void
1814 SettingsManager::OnSettingChanged(Tizen::Base::String& key)
1815 {
1816         AppLogDebug("Enter");
1817         //Flight mode changed
1818         if(key.Equals(String(SETTINGS_FLIGHT_MODE_STR)))
1819         {
1820                 bool flightMode = false;
1821                 SettingInfo::GetValue(key, flightMode);
1822                 if(flightMode == true)
1823                 {
1824                         // Notify if some active call is going on
1825                         IEnumeratorT<ISettingsEventListener*>* pListenerEnum = null;
1826                         result r = E_FAILURE;
1827                         if (__pSettingsEventListener != null)
1828                         {
1829                                 pListenerEnum = __pSettingsEventListener->GetEnumeratorN();
1830                                 //TryReturn(pListenerEnum != null, GetLastResult(), "[%s] Propagated.", GetErrorMessage(GetLastResult()));
1831
1832                                 while ((r = pListenerEnum->MoveNext()) != E_OUT_OF_RANGE)
1833                                 {
1834                                         ISettingsEventListener* pListener;
1835                                         r = pListenerEnum->GetCurrent(pListener);
1836                                         pListener->HandleFlightMode(true);
1837
1838                                 }
1839                         }
1840
1841                 }
1842         }
1843 }
1844
1845 bool
1846 SettingsManager::GetFlightModeStatus(void)
1847 {
1848     result r = E_SUCCESS;
1849
1850     String key(SETTINGS_FLIGHT_MODE_STR);
1851     bool flightMode = false;
1852
1853     r = SettingInfo::GetValue(key, flightMode);
1854     TryCatch(r == E_SUCCESS, , "GetFlightModeStatus: To get a value is failed");
1855
1856     return flightMode;
1857
1858    CATCH:
1859     return flightMode;
1860 }
1861
1862 result
1863 SettingsManager::AddToMessageRejectList(const String& phoneNumber, int matchType)       //result SettingPresentationModel::AddToFilter(const String& strFilter, int matchType)
1864 {
1865
1866         AppLogDebug("ENTER");
1867
1868         msg_error_t err = MSG_SUCCESS;
1869         result r = E_SUCCESS;
1870         msg_struct_t pFilter = msg_create_struct(MSG_STRUCT_FILTER);
1871         // Set filter type
1872         switch (matchType)
1873         {
1874         case MSG_FILTER_BY_WORD:
1875         case MSG_FILTER_BY_ADDRESS_SAME:
1876         case MSG_FILTER_BY_ADDRESS_START:
1877         case MSG_FILTER_BY_ADDRESS_INCLUDE:
1878         {
1879                 err = msg_set_int_value(pFilter, MSG_FILTER_TYPE_INT, matchType);
1880         }
1881         break;
1882         }
1883         if (err != MSG_SUCCESS)
1884         {
1885                 r = E_FAILURE;
1886                 msg_release_struct(&pFilter);
1887                 AppLogDebug("EXIT: r = %S", GetErrorMessage(r));
1888                 return r;
1889         }
1890         // Set filter string.
1891         char* pfilterString = AppUtility::ConvertStringToPointerCharArrayN(phoneNumber);
1892         err = msg_set_str_value(pFilter, MSG_FILTER_VALUE_STR, pfilterString, (int) strlen(pfilterString));
1893         if (err != MSG_SUCCESS)
1894         {
1895                 result r = E_FAILURE;
1896                 AppLogDebug("EXIT: r = %s", GetErrorMessage(r));
1897                 delete[] pfilterString;
1898                 msg_release_struct(&pFilter);
1899                 return r;
1900         }
1901
1902         r = OpenMsgHandleSession();
1903         if(r == E_FAILURE)
1904         {
1905                 AppLogDebug("Open messageing session failed!");
1906                 return r;
1907         }
1908
1909         err = msg_add_filter(__pMsgHandle, (const msg_struct_t) pFilter);
1910         if (err != MSG_SUCCESS)
1911         {
1912                 delete[] pfilterString;
1913                 r = E_FAILURE;
1914                 msg_release_struct(&pFilter);
1915                 AppLogDebug("EXIT: r = %s", GetErrorMessage(r));
1916                 return r;
1917         }
1918         delete[] pfilterString;
1919
1920         msg_release_struct(&pFilter);
1921         CloseMsgHandleSession();
1922         AppLogDebug("EXIT: r = %s", GetErrorMessage(r));
1923         return r;
1924 }
1925
1926 bool
1927 SettingsManager::GetMsgFilterListIndex(const String& phoneNumber)
1928 {
1929         AppLogDebug("ENTER");
1930         bool ret_value = false;
1931
1932         msg_error_t r = msg_open_msg_handle(&__pMsgHandle);
1933         if (r != MSG_SUCCESS)
1934         {
1935                 AppLogDebug("msg_open_msg_handle err = %d", (int) r);
1936                 return false;
1937         }
1938         __pFilterList = new (std::nothrow) msg_struct_list_s();
1939         __pFilterList->msg_struct_info = null;
1940         __pFilterList->nCount = 0;
1941         msg_get_filter_list(__pMsgHandle, __pFilterList);
1942
1943         if(__pFilterList->nCount == 0)
1944         {
1945                 return false;
1946         }
1947
1948         if(__pNumberFilterIndex == null)
1949         {
1950                 __pNumberFilterIndex = new (std::nothrow) ArrayListT< int>();
1951                 __pNumberFilterIndex->Construct();
1952         }
1953         __pNumberFilterIndex->RemoveAll();
1954
1955         // Filter out index based on filter typed.
1956         for (int index = 0,  counter = 0; index < __pFilterList->nCount; index++)
1957         {
1958                 int filterType(-1);
1959                 msg_get_int_value(__pFilterList->msg_struct_info[index], MSG_FILTER_TYPE_INT, &filterType);
1960                 if (filterType == MSG_FILTER_BY_ADDRESS_SAME)
1961                 {
1962                         __pNumberFilterIndex->Add(counter++);
1963                 }
1964         }
1965         int count = __pNumberFilterIndex->GetCount();
1966         for (int filterIndex = 0; filterIndex < count; filterIndex++)
1967         {
1968                 if (phoneNumber.CompareTo(GetFilterText(filterIndex, MSG_FILTER_BY_ADDRESS_SAME)) == 0)
1969                 {
1970                         ret_value = true;
1971                         break;
1972                 }
1973         }
1974
1975         msg_release_list_struct(__pFilterList);
1976         delete __pFilterList;
1977         __pNumberFilterIndex->RemoveAll();
1978         CloseMsgHandleSession();
1979
1980         AppLogDebug("EXIT: r = %s", GetErrorMessage(GetLastResult()));
1981
1982         return ret_value;
1983 }
1984
1985 String
1986 SettingsManager::GetFilterText(int index, int type)
1987 {
1988         AppLogDebug("ENTER");
1989
1990         result res = E_SUCCESS;
1991         msg_error_t err = MSG_SUCCESS;
1992         char filterText[MAX_FILTER_VALUE_LEN] = {0};
1993         // Get filter ID
1994         int filterIndex(-1);
1995         if (type == MSG_FILTER_BY_ADDRESS_SAME)
1996         {
1997                 __pNumberFilterIndex->GetAt(index, filterIndex);
1998         }
1999         err = msg_get_str_value(__pFilterList->msg_struct_info[filterIndex], MSG_FILTER_VALUE_STR, filterText, sizeof(filterText));
2000         if (err != MSG_SUCCESS)
2001         {
2002                 AppLogDebug("Filter text fetching err = %d", (int) err);
2003                 res = E_FAILURE;
2004         }
2005
2006         AppLogDebug("EXIT: r = %s", GetErrorMessage(res));
2007         return filterText;
2008
2009 }
2010
2011 result
2012 SettingsManager::OpenMsgHandleSession()
2013 {
2014         AppLogDebug("ENTER");
2015
2016         result r = E_SUCCESS;
2017         msg_error_t err = MSG_SUCCESS;
2018         // Open session with message service.
2019         err = msg_open_msg_handle(&__pMsgHandle);
2020         if (err != MSG_SUCCESS)
2021         {
2022                 AppLogDebug("msg_open_msg_handle err = %d", (int) err);
2023                 result r = E_FAILURE;
2024                 return r;
2025         }
2026         // On filter operation if it is disabled
2027         bool filterFlag(false);
2028         err = msg_get_filter_operation(__pMsgHandle, &filterFlag);
2029         AppLogDebug("msg_get_filter_operation err = %d", (int) err);
2030         if (!filterFlag)
2031         {
2032                 err = msg_set_filter_operation(__pMsgHandle, true);
2033                 AppLogDebug("msg_set_filter_operation err = %d", (int) err);
2034         }
2035
2036         return r;
2037 }
2038
2039 void
2040 SettingsManager::CloseMsgHandleSession()
2041 {
2042         if (__pMsgHandle != null)
2043         {
2044                 // Close open handle with message service
2045                 msg_close_msg_handle(&__pMsgHandle);
2046         }
2047 }
2048
2049
2050