src/CallTelephonyManager.cpp

   1 //
   2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Flora License, Version 1.0 (the License);
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //     http://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        CallTelephonyManager.cpp
  19  * @brief       Call log item provider
  20  */
  21 #include <stdio.h>
  22 #include <FBaseSys.h>
  23 #include <FSystem.h>
  24 #include <FTelephony.h>
  25 #include "ITapiModem.h"
  26 #include "ITapiSim.h"
  27 #include "CallInfo.h"
  28 #include "CallTelephonyManager.h"
  29 #include "CallSettingsManager.h"
  30 #include "CallTypes.h"
  31
  32 using namespace Tizen::Base;
  33 using namespace Tizen::Graphics;
  34 using namespace Tizen::Social;
  35 using namespace Tizen::System;
  36 using namespace Tizen::Base::Collection;
  37 using namespace Tizen::Telephony;
  38
  39 const char* callEventList[] = {
  40                 TAPI_NOTI_VOICE_CALL_STATUS_IDLE,
  41                 TAPI_NOTI_VOICE_CALL_STATUS_ACTIVE,
  42                 TAPI_NOTI_VOICE_CALL_STATUS_HELD,
  43                 TAPI_NOTI_VOICE_CALL_STATUS_DIALING,
  44                 TAPI_NOTI_VOICE_CALL_STATUS_ALERT,
  45                 TAPI_NOTI_VOICE_CALL_STATUS_WAITING,
  46                 TAPI_NOTI_CALL_INFO_CALL_CONNECTED_LINE,
  47                 TAPI_NOTI_CALL_INFO_WAITING,
  48                 TAPI_NOTI_CALL_INFO_CUG,
  49                 TAPI_NOTI_CALL_INFO_FORWARDED,
  50                 TAPI_NOTI_CALL_INFO_BARRED_INCOMING,
  51                 TAPI_NOTI_CALL_INFO_BARRED_OUTGOING,
  52                 TAPI_NOTI_CALL_INFO_DEFLECTED,
  53                 TAPI_NOTI_CALL_INFO_CLIR_SUPPRESSION_REJECT,
  54                 TAPI_NOTI_CALL_INFO_FORWARD_UNCONDITIONAL,
  55                 TAPI_NOTI_CALL_INFO_FORWARD_CONDITIONAL,
  56                 TAPI_NOTI_CALL_INFO_CALL_LINE_IDENTITY,
  57                 TAPI_NOTI_CALL_INFO_CALL_NAME_INFORMATION,
  58                 TAPI_NOTI_CALL_INFO_FORWARDED_CALL,
  59                 TAPI_NOTI_CALL_INFO_CUG_CALL,
  60                 TAPI_NOTI_CALL_INFO_DEFLECTED_CALL,
  61                 TAPI_NOTI_CALL_INFO_TRANSFERED_CALL,
  62                 TAPI_NOTI_CALL_INFO_HELD,
  63                 TAPI_NOTI_CALL_INFO_ACTIVE,
  64                 TAPI_NOTI_CALL_INFO_JOINED,
  65                 TAPI_NOTI_CALL_INFO_RELEASED_ON_HOLD,
  66                 TAPI_NOTI_CALL_INFO_TRANSFER_ALERT,
  67                 TAPI_NOTI_CALL_INFO_TRANSFERED,
  68                 TAPI_NOTI_CALL_INFO_CF_CHECK_MESSAGE,
  69 };
  70
  71 TelephonyManager* TelephonyManager::__pManager = null;
  72
  73 TelephonyManager::TelephonyManager(ITelephonyEventListener* pEventListener)
  74 : __pEventListener(pEventListener)
  75 {
  76         __pDialedCall = null;
  77         __pIncomingCall = null;
  78         __pActiveCallList = null;
  79         __pSettingsManager = null;
  80         __pTapiHandle = null;
  81         __pAddressBook = null;
  82         __pCachedContact = null;
  83         __isMuted = false;
  84         __isSpeakerOn = false;
  85         __pSoundManager = null;
  86         __pCalllogMgr = null;
  87         __pNetworkManager = null;
  88 }
  89
  90 TelephonyManager::~TelephonyManager(void)
  91 {
  92         if (__pActiveCallList != null)
  93         {
  94                 delete __pActiveCallList;
  95         }
  96
  97         if (__pDialedCall != null)
  98         {
  99                 delete __pDialedCall;
 100                 __pDialedCall = null;
 101         }
 102
 103         if (__pIncomingCall != null)
 104         {
 105                 delete __pIncomingCall;
 106                 __pIncomingCall = null;
 107         }
 108
 109         if (__pAddressBook != null)
 110         {
 111                 delete __pAddressBook;
 112                 __pAddressBook = null;
 113         }
 114         if (__pCachedContact != null)
 115         {
 116                 delete __pCachedContact;
 117                 __pCachedContact = null;
 118         }
 119
 120         //unregister for events from TAPI Lib.
 121         UnregisterEvents();
 122
 123         //De-initialize the TAPI Library
 124         if(__pTapiHandle != null)
 125         {
 126                 tel_deinit(__pTapiHandle);
 127         }
 128
 129         if (__pSoundManager != null)
 130         {
 131                 delete __pSoundManager;
 132         }
 133
 134         if (__pCalllogMgr != null)
 135         {
 136                 __pCalllogMgr = null;
 137         }
 138 }
 139
 140 TelephonyManager*
 141 TelephonyManager::GetInstance(ITelephonyEventListener* pEventListener)
 142 {
 143         if (__pManager == null)
 144         {
 145                 CreateInstance(pEventListener);
 146         }
 147         return __pManager;
 148 }
 149
 150 void
 151 TelephonyManager::CreateInstance(ITelephonyEventListener* pEventListener)
 152 {
 153         __pManager = new (std::nothrow) TelephonyManager(pEventListener);
 154         result r = __pManager->Initialize();
 155         if (IsFailed(r))
 156         {
 157                 delete __pManager;
 158                 __pManager = null;
 159         }
 160         atexit(&(TelephonyManager::DestroyInstance));
 161 }
 162
 163 void
 164 TelephonyManager::DestroyInstance(void)
 165 {
 166         if (__pManager != null)
 167         {
 168                 __pManager->EndAllCalls();
 169                 delete __pManager;
 170                 __pManager = null;
 171         }
 172 }
 173
 174 result
 175 TelephonyManager::Initialize(void)
 176 {
 177         //Initialize telephony library
 178         result r = InitializeTelephonyLibrary();
 179         if (IsFailed(r))
 180         {
 181                 return r;
 182         }
 183         __pActiveCallList = new (std::nothrow) HashMapT<long, AppCallInfo>();
 184         __pActiveCallList->Construct(IDI_MAX_ACTIVE_CALLS);
 185
 186         //Initialize the Settings Manager to fetch call settings
 187         __pSettingsManager = SettingsManager::GetInstance();
 188
 189         __pSoundManager = new (std::nothrow) SoundManager();
 190         __pCalllogMgr = CallLogManager::GetInstance();
 191
 192         //initialize address book to fetch contacts information
 193         __pAddressBook = AddressbookManager::GetInstance()->GetAddressbookN();
 194         if(__pAddressBook == null)
 195         {
 196                 return E_FAILURE;
 197         }
 198         __pNetworkManager = new NetworkManager();
 199         if(__pNetworkManager != null)
 200         {
 201                 __pNetworkManager->Construct(this);
 202         }
 203         return r;
 204 }
 205
 206 result
 207 TelephonyManager::InitializeTelephonyLibrary(void)
 208 {
 209         result r = E_FAILURE;
 210
 211         __pTapiHandle = tel_init(null);
 212         if (__pTapiHandle != null)
 213         {
 214                 //register telephony events
 215                 int errorCode = RegisterEvents();
 216                 if (errorCode == TAPI_CAUSE_SUCCESS)
 217                 {
 218                         r = E_SUCCESS;
 219                 }
 220         }
 221         //TAPI Library is initialized and events registered successfully
 222         return r;
 223 }
 224
 225 int
 226 TelephonyManager::RegisterEvents(void)
 227 {
 228         int errCode = -1;
 229         int eventCount = sizeof(callEventList) / sizeof(char *);
 230         for (int index = 0; index < eventCount; index++)
 231         {
 232                 errCode = tel_register_noti_event(__pTapiHandle, callEventList[index], &HandleCallback, this);
 233                 if (errCode != TAPI_API_SUCCESS)
 234                 {
 235                         return errCode;
 236                 }
 237         }
 238         return errCode;
 239 }
 240
 241 void
 242 TelephonyManager::UnregisterEvents(void)
 243 {
 244         int eventCount = sizeof(callEventList) / sizeof(char *);
 245         for (int index = 0; index < eventCount; index++)
 246         {
 247                 tel_deregister_noti_event(__pTapiHandle, callEventList[index]);
 248         }
 249 }
 250
 251 ErrorCodes
 252 TelephonyManager::SetupMoCall(String& contactNumber, bool isEmergency)
 253 {
 254         result res = E_SUCCESS;
 255         //check if valid phone number exist
 256         res = CheckValidTelePhoneNumber(contactNumber);
 257         if (IsFailed(res))
 258         {
 259                 return ERROR_INVALID_NUMBER;
 260         }
 261
 262         //if dialing an emergency call and active calls exist
 263         //then end all active calls.
 264         if (isEmergency && __pActiveCallList->GetCount() > 0)
 265         {
 266                 //Get first call handle
 267                 AppCallInfo endCallInfo;
 268                 IListT<AppCallInfo>* pCallList = __pActiveCallList->GetValuesN();
 269                 pCallList->GetAt(0, endCallInfo);
 270                 int callHandle = endCallInfo.GetCallHandle()->ToLong();
 271                 delete pCallList;
 272                 pCallList = null;
 273
 274                 //release all active or held calls
 275                 int tapiRes = tel_end_call(__pTapiHandle, callHandle, TAPI_CALL_END_ALL, &HandleCallbackResponse, this);
 276                 if (tapiRes == TAPI_CAUSE_SUCCESS)
 277                 {
 278                         __pActiveCallList->RemoveAll();
 279                         res = E_SUCCESS;
 280                 }
 281                 else
 282                 {
 283                         res = E_FAILURE;
 284                 }
 285         }
 286         else if (__pActiveCallList->GetCount() == 1)
 287         {
 288                 //Check if there is already an active call,
 289                 //Put the already active call on hold.
 290                 AppCallInfo holdCallInfo;
 291                 IListT<AppCallInfo>* pCallList = __pActiveCallList->GetValuesN();
 292
 293                 pCallList->GetAt(0, holdCallInfo);
 294                 //Check if call is active, then put on hold
 295                 if (holdCallInfo.IsOnHold() == false)
 296                 {
 297                         res = HoldActiveCall(&holdCallInfo, true);
 298                 }
 299                 delete pCallList;
 300                 pCallList = null;
 301         }
 302
 303         //make the next call, only if any existing active call
 304         //is successfully put on hold or is already on hold.
 305         if (res == E_SUCCESS)
 306         {
 307                 res = DialOutgoingCall(contactNumber, isEmergency);
 308         }
 309
 310         if(res == E_SUCCESS)
 311         {
 312                 return ERROR_NONE;
 313         }
 314         else
 315         {
 316                 return ERROR_TAPI_ERROR;
 317         }
 318 }
 319
 320 void
 321 TelephonyManager::EndAllCalls(void)
 322 {
 323         if(__pDialedCall != null)
 324         {
 325                 if(__pDialedCall->GetCallHandle() != null)
 326                 {
 327                         tel_end_call(__pTapiHandle, __pDialedCall->GetCallHandle()->ToLong(), TAPI_CALL_END, &HandleCallbackResponse, this);
 328                 }
 329         }
 330         tel_end_call(__pTapiHandle, -1, TAPI_CALL_END_HOLD_ALL, &HandleCallbackResponse, this);
 331         //end all active calls before terminating application
 332         tel_end_call(__pTapiHandle, -1, TAPI_CALL_END_ALL, &HandleCallbackResponse, this);
 333         __pSettingsManager->SetCallState(CALL_STATE_CALL_OFF);
 334 }
 335
 336 result
 337 TelephonyManager::EndActiveCall(Long callHandle)
 338 {
 339         result r = E_FAILURE;
 340
 341         //fetch ended callInfo from active call list
 342         AppCallInfo endCall;
 343         r = __pActiveCallList->GetValue(callHandle.ToLong(), endCall);
 344         if (r == E_SUCCESS)
 345         {
 346                 r = EndCall(endCall);
 347         }
 348         return r;
 349 }
 350
 351 result
 352 TelephonyManager::EndDialingCall(String& contactNumber)
 353 {
 354         result r = E_FAILURE;
 355         //This is because for a dialing call, call handle is updated with some delay in telephony manager.
 356         //And it is not available with outgoing call screen.
 357         if (contactNumber.IsEmpty())
 358         {
 359                 return r;
 360         }
 361
 362         //Check If Ended call matches Dialed Call.
 363         AppCallInfo endCall;
 364         if (__pDialedCall != null && __pDialedCall->GetContactNumber().Equals(contactNumber))
 365         {
 366                 endCall = *__pDialedCall;
 367                 r = EndCall(endCall);
 368         }
 369         return r;
 370 }
 371
 372 result
 373 TelephonyManager::EndCall(AppCallInfo& endCallInfo)
 374 {
 375         result r = E_FAILURE;
 376
 377         if (endCallInfo.GetCallHandle() != null)
 378         {
 379                 unsigned int callHandle = endCallInfo.GetCallHandle()->ToLong();
 380                 //end "dialed but unconnected" call or active call - processing to be handled in HandleIdleCallback().
 381                 int res = tel_end_call(__pTapiHandle, callHandle, TAPI_CALL_END, &HandleCallbackResponse, this);
 382                 if (res == TAPI_CAUSE_SUCCESS)
 383                 {
 384                         r = E_SUCCESS;
 385                 }
 386         }
 387         return r;
 388 }
 389
 390 result
 391 TelephonyManager::AnswerAutoRejectCall(int callHandle)
 392 {
 393         //Incoming call automatically blocked is handled here.
 394         AppLogDebug("Enter ");
 395         result r = E_FAILURE;
 396         TelCallAnswerType_t answerType = TAPI_CALL_ANSWER_REJECT;
 397         int res = -1;
 398
 399         AppLogDebug("tel_answer_call");
 400         //save to logs db.
 401         AppCallInfo rejectedCallInfo;
 402         rejectedCallInfo = *(__pIncomingCall);
 403         rejectedCallInfo.SetCalllogType(CALL_LOG_TYPE_VOICE_BLOCKED);
 404         SaveCallInfoToLogsDb(rejectedCallInfo);
 405         delete __pIncomingCall;
 406         __pIncomingCall = null;
 407
 408         // redirect to reject call back handler as the flow has to be handled
 409         res = tel_answer_call(__pTapiHandle, callHandle, answerType, &HandleCallbackResponse, this);
 410
 411         if (res == TAPI_CAUSE_SUCCESS)
 412         {
 413                 r = E_SUCCESS;
 414         }
 415         else
 416         {
 417                 r = E_FAILURE;
 418         }
 419         return r;
 420 }
 421
 422 result
 423 TelephonyManager::AnswerCall(int callHandle, bool acceptCall)
 424 {
 425         AppLogDebug("Enter %d",acceptCall);
 426         result r = E_FAILURE;
 427         __pSoundManager->StopAlert();
 428         TelCallAnswerType_t answerType = TAPI_CALL_ANSWER_ACCEPT;
 429         int res = -1;
 430         if (acceptCall == true)
 431         {
 432                 answerType = TAPI_CALL_ANSWER_ACCEPT;
 433                 // redirect to dummy call back handler as the flow already handled in registered event callback
 434                 res = tel_answer_call(__pTapiHandle, callHandle, answerType, &HandleCallbackResponse, this);
 435         }
 436         else
 437         {
 438                 AppLogDebug("tel_answer_call");
 439                 answerType = TAPI_CALL_ANSWER_REJECT;
 440                 // redirect to reject call back handler as the flow has to be handled
 441                 res = tel_answer_call(__pTapiHandle, callHandle, answerType, &HandleRejectCallbackResponse, this);
 442         }
 443
 444         if (res == TAPI_CAUSE_SUCCESS)
 445         {
 446                 r = E_SUCCESS;
 447         }
 448         else
 449         {
 450                 r = E_FAILURE;
 451         }
 452         return r;
 453 }
 454
 455 result
 456 TelephonyManager::AcceptCall(CallAnsweringOptions answerOptions,int callHandle)
 457 {
 458         result r = E_FAILURE;
 459         __pSoundManager->StopAlert();
 460         __pSoundManager->SetSoundMode(SOUND_MODE_VOICE);
 461
 462         //Check if this is a new incoming call
 463         if(__pIncomingCall == null || (callHandle != (unsigned int)__pIncomingCall->GetCallHandle()->ToLong()))
 464         {
 465                 //construct and fetch new Incoming call Info
 466                 String incomingHandle;
 467                 incomingHandle.Append(callHandle);
 468                 AppCallInfo* pDuplicateCallInfo = FetchIncomingCallHandleN(incomingHandle, String(L""));
 469                 if(pDuplicateCallInfo == null)
 470                 {
 471                         r = E_FAILURE;
 472                         return r;
 473                 }
 474                 delete pDuplicateCallInfo;
 475                 pDuplicateCallInfo = null;
 476         }
 477
 478         switch(answerOptions)
 479         {
 480         case ANSERWING_OPTION_HOLD_SINGLE_CALL:
 481         case ANSERWING_OPTION_END_SINGLE_CALL:
 482         {
 483                 r = AcceptSecondCall(answerOptions, callHandle);
 484         }
 485         break;
 486
 487         case ANSERWING_OPTION_REPLACE_ACTIVE_CALL:
 488         case ANSERWING_OPTION_REPLACE_HELD_CALL:
 489         case ANSERWING_OPTION_END_ALL_CALLS:
 490         {
 491                 r = AcceptMultipleCall(answerOptions, callHandle);
 492         }
 493         break;
 494
 495         default:
 496                 break;
 497         }
 498         return r;
 499 }
 500
 501 result
 502 TelephonyManager::AcceptSecondCall(CallAnsweringOptions answerOptions, const int incomingCallHandle)
 503 {
 504         result r = E_FAILURE;
 505
 506         switch (answerOptions)
 507         {
 508         case ANSERWING_OPTION_HOLD_SINGLE_CALL:
 509         {
 510                 //accept incoming call by putting active call on Hold with 'TAPI_CALL_ANSWER_HOLD_AND_ACCEPT'
 511                 int res = tel_answer_call(__pTapiHandle, incomingCallHandle, TAPI_CALL_ANSWER_HOLD_AND_ACCEPT, &HandleCallbackResponse, this);
 512                 if (res != 0)
 513                 {
 514                         r = E_FAILURE;
 515                         break;
 516                 }
 517
 518                 //Call connected successfully
 519                 r = E_SUCCESS;
 520                 //update status of first call to "OnHold"
 521                 IListT<AppCallInfo>* pCallList = __pActiveCallList->GetValuesN();
 522                 AppCallInfo firstCallInfo;
 523                 pCallList->GetAt(0, firstCallInfo);
 524                 //replace old object with update AppCallInfo
 525                 AppCallInfo* pHeldCallInfo = new (std::nothrow) AppCallInfo();
 526                 *pHeldCallInfo = firstCallInfo;
 527                 pHeldCallInfo->SetOnHold(true);
 528                 __pActiveCallList->Remove(firstCallInfo.GetCallHandle()->ToLong());
 529                 __pActiveCallList->Add(pHeldCallInfo->GetCallHandle()->ToLong(), *pHeldCallInfo);
 530                 delete pCallList;
 531                 pCallList = null;
 532         }
 533         break;
 534
 535         case ANSERWING_OPTION_END_SINGLE_CALL:
 536         {
 537                 //Transfer Old active calls to a separate list to avoid any processing in HandleIdleCallback().
 538                 HashMapT<long, AppCallInfo>*  pEndCallsList = __pActiveCallList;
 539                 //create a new ActiveCallList
 540                 __pActiveCallList = new (std::nothrow) HashMapT<long, AppCallInfo>();
 541                 __pActiveCallList->Construct(IDI_MAX_ACTIVE_CALLS);
 542
 543                 //accept call and reject all active calls with 'TAPI_CALL_ANSWER_REPLACE'
 544                 int res = tel_answer_call(__pTapiHandle, incomingCallHandle, TAPI_CALL_ANSWER_REPLACE, &HandleCallbackResponse, this);
 545                 if (res != 0)
 546                 {
 547                         r = E_FAILURE;
 548                         //delete newly constructed list and gain ownership of old list
 549                         delete __pActiveCallList;
 550                         __pActiveCallList = pEndCallsList;
 551                         break;
 552                 }
 553
 554                 //Call connected successfully
 555                 r = E_SUCCESS;
 556                 //Add calls information to call log before deleting from active call list.
 557                 IListT<AppCallInfo>* pCallList = pEndCallsList->GetValuesN();
 558                 if(pCallList != null)
 559                 {
 560                         AppCallInfo endCallInfo;
 561                         if (pCallList->GetAt(0, endCallInfo) == E_SUCCESS)
 562                         {
 563                                 SaveCallInfoToLogsDb(endCallInfo);
 564                         }
 565                         delete pCallList;
 566                 }
 567                 pEndCallsList->RemoveAll();
 568                 delete pEndCallsList;
 569         }
 570         break;
 571
 572         default:
 573                 break;
 574         }
 575         return r;
 576 }
 577
 578 result
 579 TelephonyManager::AcceptMultipleCall(CallAnsweringOptions answerOptions, const int incomingCallHandle)
 580 {
 581         result r = E_FAILURE;
 582
 583         switch (answerOptions)
 584         {
 585         case ANSERWING_OPTION_REPLACE_ACTIVE_CALL:
 586         {
 587                 //Replace "Active" call by incoming call and save ended call to call logs db.
 588                 IListT<AppCallInfo>* pCallList = __pActiveCallList->GetValuesN();
 589                 AppCallInfo callToBeEnded;
 590                 pCallList->GetAt(0, callToBeEnded);
 591                 //Check if the call is on "Hold", then fetch 2nd callInfo
 592                 if (callToBeEnded.IsOnHold() == true)
 593                 {
 594                         pCallList->GetAt(1, callToBeEnded);
 595                 }
 596                 delete pCallList;
 597                 pCallList = null;
 598
 599                 //remove "CallToBeEnded" from Active call list to avoid processing in HandleIdleCallback().
 600                 __pActiveCallList->Remove(callToBeEnded.GetCallHandle()->ToLong());
 601
 602                 //Accept incoming call by End Active call with 'TAPI_CALL_ANSWER_REPLACE'
 603                 int res = tel_answer_call(__pTapiHandle, incomingCallHandle, TAPI_CALL_ANSWER_REPLACE, &HandleCallbackResponse, this);
 604                 if (res != 0)
 605                 {
 606                         r = E_FAILURE;
 607                         //save the previous call back to active call list
 608                         __pActiveCallList->Add(callToBeEnded.GetCallHandle()->ToLong(), callToBeEnded);
 609                         break;
 610                 }
 611
 612                 //Incoming Call connected successfully
 613                 r = E_SUCCESS;
 614                 //save to ended call to call logs db.
 615                 SaveCallInfoToLogsDb(callToBeEnded);
 616         }
 617         break;
 618
 619         case ANSERWING_OPTION_REPLACE_HELD_CALL:
 620         {
 621                 //Replace "Held" call by incoming call and save ended call to call logs db.
 622                 IListT<AppCallInfo>* pCallList = __pActiveCallList->GetValuesN();
 623                 //"Held" call is to be ended
 624                 AppCallInfo callToBeEnded;
 625                 //"Active" call will be put on Hold
 626                 AppCallInfo callToPutOnHold;
 627                 pCallList->GetAt(0, callToBeEnded);
 628                 //Check if the call is NOT "Held", then fetch 2nd callInfo
 629                 if (callToBeEnded.IsOnHold() == false)
 630                 {
 631                         callToPutOnHold = callToBeEnded;
 632                         pCallList->GetAt(1, callToBeEnded);
 633                 }
 634                 else
 635                 {
 636                         pCallList->GetAt(1, callToPutOnHold);
 637                 }
 638                 delete pCallList;
 639                 pCallList = null;
 640
 641                 //remove "CallToBeEnded" from Active call list to avoid processing in HandleIdleCallback().
 642                 __pActiveCallList->Remove(callToBeEnded.GetCallHandle()->ToLong());
 643
 644                 //End "Held" Call using 'TAPI_CALL_END'.
 645                 int res = -1;
 646                 if (callToBeEnded.IsConferenceCall() == false)
 647                 {
 648                         res = tel_end_call(__pTapiHandle, callToBeEnded.GetCallHandle()->ToLong(), TAPI_CALL_END, &HandleCallbackResponse, this);
 649                 }
 650                 else
 651                 {
 652                         IListT<AppCallInfo>* pParticipantsInfo = callToBeEnded.GetCallerList();
 653                         //need to end every participant individually for conference call
 654                         for (int index = 0; index < pParticipantsInfo->GetCount(); index++)
 655                         {
 656                                 AppCallInfo memberCallInfo;
 657                                 pParticipantsInfo->GetAt(index, memberCallInfo);
 658                                 res = tel_end_call(__pTapiHandle, memberCallInfo.GetCallHandle()->ToLong(), TAPI_CALL_END, &HandleCallbackResponse, this);
 659                         }
 660                 }
 661
 662                 if (res != 0)
 663                 {
 664                         r = E_FAILURE;
 665                         //save the previous "callToBeEnded" call back to active call list
 666                         __pActiveCallList->Add(callToBeEnded.GetCallHandle()->ToLong(), callToBeEnded);
 667                         break;
 668                 }
 669                 //"Held" call successfully ended - Add call ended to call log database
 670                 SaveCallInfoToLogsDb(callToBeEnded);
 671
 672                 //accept incoming call by Holding "Active" call using "TAPI_CALL_ANSWER_HOLD_AND_ACCEPT".
 673                 res = tel_answer_call(__pTapiHandle, incomingCallHandle, TAPI_CALL_ANSWER_HOLD_AND_ACCEPT, &HandleCallbackResponse, this);
 674                 if (res != 0)
 675                 {
 676                         r = E_FAILURE;
 677                         break;
 678                 }
 679
 680                 //Call connected successfully and active call is "Onhold"
 681                 r = E_SUCCESS;
 682                 //replace old object with update CallInfo
 683                 AppCallInfo* pHeldCallInfo = new (std::nothrow) AppCallInfo();
 684                 *pHeldCallInfo = callToPutOnHold;
 685                 pHeldCallInfo->SetOnHold(true);
 686                 __pActiveCallList->Remove(callToPutOnHold.GetCallHandle()->ToLong());
 687                 __pActiveCallList->Add(pHeldCallInfo->GetCallHandle()->ToLong(), *pHeldCallInfo);
 688         }
 689         break;
 690
 691         case ANSERWING_OPTION_END_ALL_CALLS:
 692         {
 693                 //End all active and Held calls after saving to call log. Incoming call is automatically accepted by TAPI engine,
 694                 // and processing of Incoming call is handled in HandleActiveCallback().
 695
 696                 //Transfer Old active calls to a separate list to avoid any processing in HandleIdleCallback().
 697                 HashMapT<long, AppCallInfo>*  pEndCallsList = __pActiveCallList;
 698                 //create a new ActiveCallList
 699                 __pActiveCallList = new (std::nothrow) HashMapT<long, AppCallInfo>();
 700                 __pActiveCallList->Construct(IDI_MAX_ACTIVE_CALLS);
 701
 702                 //End all active calls and all hold calls
 703                 int res = tel_end_call(__pTapiHandle, -1, TAPI_CALL_END_ACTIVE_ALL, &HandleCallbackResponse, this);
 704                 if(res == 0)
 705                 {
 706                         res = tel_end_call(__pTapiHandle, -1, TAPI_CALL_END_HOLD_ALL, &HandleCallbackResponse, this);
 707                 }
 708
 709                 if (res != 0)
 710                 {
 711                         r = E_FAILURE;
 712                         //delete newly constructed list and gain ownership of old list
 713                         delete __pActiveCallList;
 714                         __pActiveCallList = pEndCallsList;
 715                         break;
 716                 }
 717
 718                 //all calls ended successfully, Incoming call is automatically accepted.
 719                 r = E_SUCCESS;
 720
 721                 //Add calls information to call log before deleting from active call list.
 722                 IListT<AppCallInfo>* pCallList = pEndCallsList->GetValuesN();
 723                 if(pCallList != null)
 724                 {
 725                         int callCount = pCallList->GetCount();
 726                         for (int index = 0; index < callCount; index++)
 727                         {
 728                                 AppCallInfo endCallInfo;
 729                                 if (pCallList->GetAt(index, endCallInfo) == E_SUCCESS)
 730                                 {
 731                                         SaveCallInfoToLogsDb(endCallInfo);
 732                                 }
 733                         }
 734                         delete pCallList;
 735                         pCallList = null;
 736                 }
 737                 pEndCallsList->RemoveAll();
 738                 delete pEndCallsList;
 739                 pEndCallsList = null;
 740         }
 741         break;
 742
 743         default:
 744                 break;
 745         }
 746         return r;
 747 }
 748
 749 result
 750 TelephonyManager::HoldCall(Tizen::Base::Long callHandle, bool holdCall)
 751 {
 752         result r = E_SUCCESS;
 753         //Check if there are any existing active calls
 754         if (__pActiveCallList->GetCount())
 755         {
 756                 IListT<AppCallInfo>* pCallList = __pActiveCallList->GetValuesN();
 757                 int callCount = pCallList->GetCount();
 758                 for (int index = 0; index < callCount; index++)
 759                 {
 760                         AppCallInfo holdCallInfo;
 761
 762                         r = pCallList->GetAt(index, holdCallInfo);
 763                         //check if an active call is found with matching contact no.
 764                         if ((r == E_SUCCESS) && (holdCallInfo.GetCallHandle()->Equals(callHandle)))
 765                         {
 766                                 r = HoldActiveCall(&holdCallInfo, holdCall);
 767                                 break;
 768                         }
 769                 }
 770                 delete pCallList;
 771                 pCallList = null;
 772         }
 773
 774         return r;
 775 }
 776
 777 result
 778 TelephonyManager::EndConferenceCall(void)
 779 {
 780         result r = E_FAILURE;
 781         //fetch conference callInfo to end
 782         AppCallInfo confCallToEnd;
 783         bool isConferenceCallFound = false;
 784
 785         IListT<AppCallInfo>* pCallList = __pActiveCallList->GetValuesN();
 786         int callCount = pCallList->GetCount();
 787         for (int index = 0; index < callCount; index++)
 788         {
 789                 pCallList->GetAt(index, confCallToEnd);
 790                 if (confCallToEnd.IsConferenceCall() == true)
 791                 {
 792                         isConferenceCallFound = true;
 793                         break;
 794                 }
 795         }
 796         delete pCallList;
 797         pCallList = null;
 798
 799         if (isConferenceCallFound == true)
 800         {
 801                 //End conference call
 802                 TelCallEndType_t callEndType = TAPI_CALL_END_ACTIVE_ALL;
 803                 if (confCallToEnd.IsOnHold() == true)
 804                 {
 805                         callEndType = TAPI_CALL_END_HOLD_ALL;
 806                 }
 807                 int res = tel_end_call(__pTapiHandle, confCallToEnd.GetCallHandle()->ToLong(), callEndType, &HandleEndConferenceCallbackResponse, this);
 808                 if (res == TAPI_CAUSE_SUCCESS)
 809                 {
 810                         r = E_SUCCESS;
 811                 }
 812         }
 813         return r;
 814 }
 815
 816 result
 817 TelephonyManager::HoldConferenceCall(bool holdCall)
 818 {
 819         result r = E_FAILURE;
 820         int confCallIndex = -1;
 821         AppCallInfo confCallToHold;
 822         bool isConferenceCallFound = false;
 823
 824         IListT<AppCallInfo>* pCallList = __pActiveCallList->GetValuesN();
 825         int confCallCount = pCallList->GetCount();
 826
 827         for (int index = 0; index < confCallCount; index++)
 828         {
 829                 pCallList->GetAt(index, confCallToHold);
 830                 if (confCallToHold.IsConferenceCall() == true)
 831                 {
 832                         isConferenceCallFound = true;
 833                         confCallIndex = index;
 834                         //Found the Conference call to be ended.
 835                         break;
 836                 }
 837         }
 838
 839         if (isConferenceCallFound == false)
 840         {
 841                 delete pCallList;
 842                 pCallList = null;
 843                 return r;
 844         }
 845
 846         unsigned int callHandle = confCallToHold.GetCallHandle()->ToLong();
 847         int res = TAPI_API_INVALID_INPUT;
 848         if (holdCall == true)
 849         {
 850                 res = tel_hold_call(__pTapiHandle, callHandle, &HandleCallbackResponse, this);
 851         }
 852         else
 853         {
 854                 res = tel_active_call(__pTapiHandle, callHandle, &HandleCallbackResponse, this);
 855         }
 856         if (res == TAPI_API_SUCCESS)
 857         {
 858                 r = E_SUCCESS;
 859                 if (holdCall == true)
 860                 {
 861                         confCallToHold.SetOnHold(true);
 862                 }
 863                 else
 864                 {
 865                         confCallToHold.SetOnHold(false);
 866                 }
 867                 AppCallInfo* pConfCallInfo = new (std::nothrow) AppCallInfo();
 868                 *pConfCallInfo = confCallToHold;
 869                 __pActiveCallList->Remove(callHandle);
 870                 __pActiveCallList->Add(callHandle, *pConfCallInfo);
 871         }
 872         else
 873         {
 874                 r = E_FAILURE;
 875         }
 876
 877         delete pCallList;
 878         pCallList = null;
 879         return r;
 880 }
 881
 882 result
 883 TelephonyManager::JoinCall(void)
 884 {
 885         result r = E_FAILURE;
 886         int res = -1;
 887         AppCallInfo activeCall;
 888         AppCallInfo heldCall;
 889         // Use enumerator to access elements in the map
 890         IListT<AppCallInfo>* pCallList = __pActiveCallList->GetValuesN();
 891         r = pCallList->GetAt(0, activeCall);
 892
 893         if (r == E_SUCCESS)
 894         {
 895                 r = pCallList->GetAt(1, heldCall);
 896                 if (r == E_SUCCESS)
 897                 {
 898                         unsigned int activeCallHandle = activeCall.GetCallHandle()->ToLong();
 899                         unsigned int heldCallHandle = heldCall.GetCallHandle()->ToLong();
 900
 901                         //Check if participants in conference call are under limit.
 902                         if ((heldCall.IsConferenceCall() == true) && (heldCall.GetCallerListCount() < IDI_MAX_CONF_CALL_PARTICIPANTS))
 903                         {
 904                                 res = tel_join_call(__pTapiHandle, heldCallHandle, activeCallHandle, &HandleJoinCallbackResponse, this);
 905                         }
 906                         else if (activeCall.GetCallerListCount() < IDI_MAX_CONF_CALL_PARTICIPANTS)
 907                         {
 908                                 res = tel_join_call(__pTapiHandle, activeCallHandle, heldCallHandle, &HandleJoinCallbackResponse, this);
 909                         }
 910                 }
 911         }
 912         delete pCallList;
 913         pCallList = null;
 914         if (res == TAPI_API_SUCCESS)
 915         {
 916                 r = E_SUCCESS;
 917         }
 918         else
 919         {
 920                 r = E_FAILURE;
 921         }
 922         return r;
 923 }
 924
 925 result
 926 TelephonyManager::HoldActiveCall(AppCallInfo* pActiveCallInfo, bool holdCall)
 927 {
 928         unsigned int callHandle = pActiveCallInfo->GetCallHandle()->ToLong();
 929         int retStatus = -1;
 930         if (holdCall == true)
 931         {
 932                 retStatus = tel_hold_call(__pTapiHandle, callHandle, &HandleCallbackResponse, this);
 933         }
 934         else
 935         {
 936                 retStatus = tel_active_call(__pTapiHandle, callHandle, &HandleCallbackResponse, this);
 937         }
 938
 939         if (retStatus == TAPI_CAUSE_SUCCESS)
 940         {
 941                 AppCallInfo* pHeldCallInfo = new (std::nothrow) AppCallInfo();
 942                 //copy state into new callinfo object
 943                 *pHeldCallInfo = *pActiveCallInfo;
 944
 945                 //set call to hold state
 946                 pHeldCallInfo->SetOnHold(holdCall);
 947
 948                 __pActiveCallList->Remove(callHandle);
 949                 //replace old object with new
 950                 __pActiveCallList->Add(callHandle, *pHeldCallInfo);
 951                 return E_SUCCESS;
 952         }
 953         else
 954         {
 955                 return E_FAILURE;
 956         }
 957 }
 958
 959 result
 960 TelephonyManager::DialOutgoingCall(String& contactNumber, bool isEmergency)
 961 {
 962         TelCallDial_t structDialCall;
 963
 964         AppLogDebug("Enter %ls",contactNumber.GetPointer());
 965         //Temp String to replace , with P and ; with W
 966         String TempContactNum;
 967         TempContactNum.Append(contactNumber);
 968         TempContactNum.Replace(L",",L"W");
 969         TempContactNum.Replace(L";",L",");
 970         //conversion "contactNumber" to char*
 971         const wchar_t* pContact = TempContactNum.GetPointer();
 972         int len = TempContactNum.GetLength()+1;
 973         char* pNumber = new (std::nothrow) char[len];
 974         wcstombs(pNumber, pContact, len);
 975
 976
 977         //initialize request parameter
 978         memset(&structDialCall, '\0', sizeof(TelCallDial_t));
 979         memcpy(structDialCall.szNumber, pNumber, strlen(pNumber));
 980         AppLogDebug("%s",structDialCall.szNumber);
 981         if(isEmergency == true)
 982         {
 983                 structDialCall.CallType = TAPI_CALL_TYPE_E911;
 984         }
 985         else
 986         {
 987                 structDialCall.CallType = TAPI_CALL_TYPE_VOICE;
 988         }
 989
 990         int res = tel_dial_call(__pTapiHandle, &structDialCall, &HandleDialCallbackResponse, this);
 991         if (__pSoundManager == null)
 992         {
 993                 __pSoundManager = new (std::nothrow) SoundManager();
 994         }
 995         __pSoundManager->StartSession();
 996         delete[] pNumber;
 997         pNumber = null;
 998
 999         if (res == TAPI_CAUSE_SUCCESS)
1000         {
1001                 if (__pDialedCall != null)
1002                 {
1003                         delete __pDialedCall;
1004                         __pDialedCall = null;
1005                 }
1006                 __pDialedCall = new (std::nothrow) AppCallInfo();
1007                 __pDialedCall->SetContactNumber(contactNumber);
1008                 __pDialedCall->SetEmergency(isEmergency);
1009                 result r = FetchContactInfoForNumber(contactNumber);
1010                 if (!IsFailed(r))
1011                 {
1012                         __pDialedCall->SetContactInfo(*__pCachedContact);
1013                 }
1014                 return E_SUCCESS;
1015         }
1016         else
1017         {
1018                 return E_FAILURE;
1019         }
1020 }
1021
1022 result
1023 TelephonyManager::SwapCalls(void)
1024 {
1025         result r = E_FAILURE;
1026
1027         //check if there are atleast 2 active calls
1028         if (__pActiveCallList->GetCount() == IDI_MAX_ACTIVE_CALLS)
1029         {
1030                 int retStatus = 0;
1031
1032                 //fetch call handles
1033                 IListT<long>* pCallHandleList = __pActiveCallList->GetKeysN();
1034                 long callHandle1 = 0;
1035                 pCallHandleList->GetAt(0, callHandle1);
1036                 long callHandle2 = 0;
1037                 pCallHandleList->GetAt(1, callHandle2);
1038
1039                 retStatus = tel_swap_call(__pTapiHandle, callHandle1, callHandle2, &HandleSwapCallbackResponse, this);
1040
1041                 if (retStatus == TAPI_CAUSE_SUCCESS)
1042                 {
1043                         r = E_SUCCESS;
1044                 }
1045                 delete pCallHandleList;
1046                 pCallHandleList = null;
1047         }
1048
1049         return r;
1050 }
1051
1052 result
1053 TelephonyManager::SendCallDTMF(String& textToBeSent)
1054 {
1055         result r = E_FAILURE;
1056         //check if there is an active Call
1057         if (__pActiveCallList->GetCount() > 0)
1058         {
1059                 //conversion "textToBeSent" to char*
1060                 const wchar_t* pTextToBeSent = textToBeSent.GetPointer();
1061                 int len = textToBeSent.GetLength() + 1;
1062                 char* pNumber = new (std::nothrow) char[len];
1063                 wcstombs(pNumber, pTextToBeSent, len);
1064                 int retStatus = tel_call_dtmf(__pTapiHandle, pNumber, &HandleCallbackResponse, this);
1065                 delete []pNumber;
1066                 pNumber = null;
1067                 if (retStatus == TAPI_CAUSE_SUCCESS)
1068                 {
1069                         r = E_SUCCESS;
1070                 }
1071         }
1072         return r;
1073 }
1074
1075 result
1076 TelephonyManager::EndFromConference(int callHandle)
1077 {
1078         result r = E_FAILURE;
1079         int confCallIndex = -1;
1080         AppCallInfo endConfCall;
1081         bool isConferenceCallFound = false;
1082
1083         IListT<AppCallInfo>* pCallList = __pActiveCallList->GetValuesN();
1084         int callCount = pCallList->GetCount();
1085         for (int index = 0; index < callCount; index++)
1086         {
1087                 pCallList->GetAt(index, endConfCall);
1088                 if (endConfCall.IsConferenceCall() == true)
1089                 {
1090                         isConferenceCallFound = true;
1091                         confCallIndex = index;
1092                         //Found the Conference call to be ended.
1093                         break;
1094                 }
1095         }
1096
1097         delete pCallList;
1098         pCallList = null;
1099
1100         if (isConferenceCallFound == false)
1101         {
1102                 //no conference call found
1103                 return r;
1104         }
1105
1106         //Identify the call to be ended and remove from list on API success
1107         AppCallInfo callToBeEnded;
1108         IListT<AppCallInfo>* pParticipantList = endConfCall.GetCallerList();
1109         int participantCount = pParticipantList->GetCount();
1110         for (int index = 0; index < participantCount; index++)
1111         {
1112                 pParticipantList->GetAt(index, callToBeEnded);
1113                 if (callToBeEnded.GetCallHandle()->ToLong() == callHandle)
1114                 {
1115                         //Identify the call to be ended and remove from list on API success
1116                         TelCallEndType_t endType = TAPI_CALL_END;
1117
1118                         int res = tel_end_call(__pTapiHandle, callHandle, endType, &HandleEndFromConferenceCallbackResponse, this);
1119                         if (res == TAPI_CAUSE_SUCCESS)
1120                         {
1121                                 r = E_SUCCESS;
1122                         }
1123                         else
1124                         {
1125                                 r = E_FAILURE;
1126                         }
1127                         break;
1128                 }
1129         }
1130
1131         return r;
1132 }
1133
1134 result
1135 TelephonyManager::SplitFromConference(int callHandle)
1136 {
1137         result r = E_FAILURE;
1138         int confCallIndex = -1;
1139         AppCallInfo endConfCall;
1140         bool isConferenceCallFound = false;
1141
1142         IListT<AppCallInfo>* pCallList = __pActiveCallList->GetValuesN();
1143         int callCount = pCallList->GetCount();
1144         for (int index = 0; index < callCount; index++)
1145         {
1146                 pCallList->GetAt(index, endConfCall);
1147                 if (endConfCall.IsConferenceCall() == true)
1148                 {
1149                         isConferenceCallFound = true;
1150                         confCallIndex = index;
1151                         //Found the Conference call to be ended.
1152                         break;
1153                 }
1154         }
1155         delete pCallList;
1156         pCallList = null;
1157         if (isConferenceCallFound == false)
1158         {
1159                 //no conference call found
1160                 return r;
1161         }
1162
1163         //Identify the call to be ended and remove from list on API success
1164         AppCallInfo callToBeEnded;
1165         pCallList = endConfCall.GetCallerList();
1166         callCount = pCallList->GetCount();
1167         for (int index = 0; index < callCount; index++)
1168         {
1169                 pCallList->GetAt(index, callToBeEnded);
1170                 if (callToBeEnded.GetCallHandle()->ToLong() == callHandle)
1171                 {
1172                         int res = tel_split_call(__pTapiHandle, callHandle, &HandleSplitFromConferenceCallbackResponse, this);
1173                         if (res == TAPI_CAUSE_SUCCESS)
1174                         {
1175                                 r = E_SUCCESS;
1176                         }
1177                         else
1178                         {
1179                                 r = E_FAILURE;
1180                         }
1181                         break;
1182                 }
1183         }
1184         return r;
1185 }
1186
1187 result
1188 TelephonyManager::SetMuteStatus(bool setMute)
1189 {
1190         TelSoundMuteStatus_t muteStatus;
1191         result r = E_FAILURE;
1192         if (setMute == true)
1193         {
1194                 muteStatus = TAPI_SOUND_MUTE_STATUS_ON;
1195         }
1196         else
1197         {
1198                 muteStatus = TAPI_SOUND_MUTE_STATUS_OFF;
1199         }
1200         int res = tel_set_call_mute_status(__pTapiHandle, muteStatus, &HandleCallbackResponse, this);
1201         if (res == TAPI_CAUSE_SUCCESS)
1202         {
1203                 __isMuted = setMute;
1204                 r = E_SUCCESS;
1205         }
1206         else
1207         {
1208                 r = E_FAILURE;
1209         }
1210         return r;
1211 }
1212
1213 bool
1214 TelephonyManager::IsCallMuted(void)
1215 {
1216         return __isMuted;
1217 }
1218
1219 result
1220 TelephonyManager::SetSpeakerStatus(bool setSpeaker)
1221 {
1222         result r = E_FAILURE;
1223         TelCallSoundPathInfo_t callSoundPathInfo;
1224         __pSoundManager->SetSpeakerStatus(setSpeaker);
1225         if (setSpeaker == true)
1226         {
1227                 callSoundPathInfo.path = TAPI_SOUND_PATH_SPK_PHONE;
1228         }
1229         else
1230         {
1231                 callSoundPathInfo.path = TAPI_SOUND_PATH_HANDSET;
1232         }
1233         callSoundPathInfo.ex_volume = TelCallSoundPathInfo_t::TAPI_SOUND_EX_VOLUME_ON;
1234
1235         int res = tel_set_call_sound_path(__pTapiHandle, &callSoundPathInfo, &HandleCallbackResponse, this);
1236
1237         if (res == TAPI_CAUSE_SUCCESS)
1238         {
1239                 __isSpeakerOn = setSpeaker;
1240                 r = E_SUCCESS;
1241         }
1242         else
1243         {
1244                 r = E_FAILURE;
1245         }
1246         return r;
1247 }
1248
1249 bool
1250 TelephonyManager::IsSpeakerOn(void)
1251 {
1252         return __isSpeakerOn;
1253 }
1254
1255 bool
1256 TelephonyManager::IsSplitAllowed(void)
1257 {
1258         // Split functionality is allowed only if a one call is present.
1259         // The call can be a single call or a conference call
1260         if (__pActiveCallList->GetCount() == 1)
1261         {
1262                 return true;
1263         }
1264         return false;
1265 }
1266
1267 void
1268 TelephonyManager::HandleCallbackResponse(TapiHandle* pHandle, int callBackResult, void* pData, void* pUserData)
1269 {
1270         //should not do anything here.
1271 }
1272
1273 void
1274 TelephonyManager::HandleDialCallbackResponse(TapiHandle* pHandle, int callBackResult, void* pData, void* pUserData)
1275 {
1276         TelephonyManager* pTelManager = (TelephonyManager*) pUserData;
1277         if (callBackResult != TAPI_CAUSE_SUCCESS)
1278         {
1279                 if (pTelManager->__pDialedCall != null)
1280                 {
1281                         delete pTelManager->__pDialedCall;
1282                         pTelManager->__pDialedCall = null;
1283                 }
1284                 pTelManager->__pEventListener->HandleTelephonyError(ERROR_DIAL_FAILED);
1285         }
1286 }
1287
1288 void
1289 TelephonyManager::HandleRejectCallbackResponse(TapiHandle* pHandle, int callBackResult, void* pData, void* pUserData)
1290 {
1291         AppLogDebug("ENTER");
1292         // This callback comes only if user has rejected an incoming call from IncomingCallForm.
1293         TelephonyManager* pTelManager = (TelephonyManager*) pUserData;
1294         if (pData != null && callBackResult == TAPI_API_SUCCESS)
1295         {
1296                 unsigned int rejectedCallHandle = 0;
1297                 memcpy(&rejectedCallHandle, pData, sizeof(TS_UINT));
1298
1299                 //Check if incoming call is rejected
1300                 if (pTelManager->__pIncomingCall != null && (rejectedCallHandle == (unsigned int) pTelManager->__pIncomingCall->GetCallHandle()->ToLong()))
1301                 {
1302                         AppLogDebug("Call rejected by user");
1303                         AppCallInfo rejectedCallInfo;
1304                         rejectedCallInfo = *(pTelManager->__pIncomingCall);
1305                         delete pTelManager->__pIncomingCall;
1306                         pTelManager->__pIncomingCall = null;
1307
1308                         //rejected by user from incoming call form
1309                         rejectedCallInfo.SetCalllogType(CALL_LOG_TYPE_VOICE_REJECTED);
1310                         //Save rejected incoming call to call log db.
1311                         pTelManager->SaveCallInfoToLogsDb(rejectedCallInfo);
1312
1313                         //check if the ended call was the last call
1314                         bool isLastCall = (pTelManager->__pActiveCallList->GetCount() == 0);
1315                         //Stop alert - started only for incoming calls which are not blocked.
1316                         if(pTelManager->__pSoundManager != null)
1317                         {
1318                                 pTelManager->__pSoundManager->StopAlert();
1319                                 //Do not call stop session if there is already a call going on
1320                                 if(isLastCall == true)
1321                                 {
1322                                         pTelManager->__pSoundManager->StopSession();
1323                                 }
1324                         }
1325                         //Send notification to user
1326                         ArrayListT<AppCallInfo>* pCallList = null;
1327                         if (isLastCall)
1328                         {
1329                                 //save 'RejectedCall' to list to show on EndCallForm
1330                                 pCallList = new (std::nothrow) ArrayListT<AppCallInfo>();
1331                                 pCallList->Construct(1);
1332                                 AppCallInfo* pRejectedCall = new (std::nothrow) AppCallInfo();
1333                                 *pRejectedCall = rejectedCallInfo;
1334                                 pCallList->Add(*pRejectedCall);
1335                         }
1336                         else
1337                         {
1338                                 //fetch active calls to show appropriate scene
1339                                 pCallList = static_cast<ArrayListT<AppCallInfo>*>(pTelManager->__pActiveCallList->GetValuesN());
1340                         }
1341                         pTelManager->__pEventListener->HandleCallDisconnected(isLastCall, *pCallList);
1342                         delete pCallList;
1343                         pCallList = null;
1344                 }
1345         }
1346         else
1347         {
1348                 pTelManager->__pEventListener->HandleTelephonyError(ERROR_REJECT_FAILED);
1349         }
1350         AppLogDebug("EXIT");
1351 }
1352
1353 void
1354 TelephonyManager::HandleJoinCallbackResponse(TapiHandle* pHandle, int callBackResult, void* pData, void* pUserData)
1355 {
1356         TelephonyManager* pTelManager = (TelephonyManager*) pUserData;
1357         if (callBackResult == TAPI_API_SUCCESS && pData != null)
1358         {
1359                 unsigned int tempHandle = 0;
1360                 TelCallInfoJoinedNoti_t joinedInfoNotification;
1361                 AppCallInfo confCallInfo;
1362
1363                 memcpy(&tempHandle, pData, sizeof(TS_UINT));
1364                 joinedInfoNotification.id = tempHandle;
1365                 AppCallInfo activeCall;
1366                 AppCallInfo heldCall;
1367                 // Use enumerator to access elements in the map
1368                 IListT<AppCallInfo>* pCallList = pTelManager->__pActiveCallList->GetValuesN();
1369                 result r = pCallList->GetAt(0, activeCall);
1370
1371                 if (r == E_SUCCESS)
1372                 {
1373                         r = pCallList->GetAt(1, heldCall);
1374                         if (r == E_SUCCESS)
1375                         {
1376                                 AppCallInfo* pConfCallInfo = new (std::nothrow) AppCallInfo();
1377                                 unsigned int activeCallHandle = activeCall.GetCallHandle()->ToLong();
1378                                 unsigned int heldCallHandle = heldCall.GetCallHandle()->ToLong();
1379                                 if (activeCall.IsConferenceCall() == true)
1380                                 {
1381                                         r = E_SUCCESS;
1382                                         //When joined both become active
1383                                         activeCall.SetOnHold(false);
1384                                         heldCall.SetOnHold(false);
1385                                         *pConfCallInfo = activeCall;
1386                                         pConfCallInfo->AddCallToCallerList(heldCall);
1387                                         pConfCallInfo->SetCallHandle(activeCallHandle);
1388                                         //Set call start time
1389                                         if (pConfCallInfo->GetCallConnectTime() > heldCall.GetCallConnectTime())
1390                                         {
1391                                                 pConfCallInfo->SetCallConnectTime(heldCall.GetCallConnectTime());
1392                                                 pConfCallInfo->SetCallNotificationTime(heldCall.GetCallNotificationTime());
1393                                         }
1394                                 }
1395                                 else if (heldCall.IsConferenceCall() == true)
1396                                 {
1397                                         r = E_SUCCESS;
1398                                         heldCall.SetOnHold(false);
1399                                         activeCall.SetOnHold(false);
1400                                         *pConfCallInfo = heldCall;
1401                                         pConfCallInfo->AddCallToCallerList(activeCall);
1402                                         pConfCallInfo->SetCallHandle(heldCallHandle);
1403                                         //Set call start time
1404                                         if (pConfCallInfo->GetCallConnectTime() > activeCall.GetCallConnectTime())
1405                                         {
1406                                                 pConfCallInfo->SetCallConnectTime(activeCall.GetCallConnectTime());
1407                                                 pConfCallInfo->SetCallNotificationTime(activeCall.GetCallNotificationTime());
1408                                         }
1409                                 }
1410                                 else
1411                                 {
1412                                         r = E_SUCCESS;
1413                                         pConfCallInfo->SetConference(true);
1414                                         heldCall.SetOnHold(false);
1415                                         activeCall.SetOnHold(false);
1416                                         pConfCallInfo->AddCallToCallerList(activeCall);
1417                                         pConfCallInfo->AddCallToCallerList(heldCall);
1418                                         pConfCallInfo->SetCallHandle(activeCallHandle);
1419                                         //Set call start time
1420                                         if (activeCall.GetCallConnectTime() > heldCall.GetCallConnectTime())
1421                                         {
1422                                                 pConfCallInfo->SetCallConnectTime(heldCall.GetCallConnectTime());
1423                                                 pConfCallInfo->SetCallNotificationTime(heldCall.GetCallNotificationTime());
1424                                         }
1425                                         else
1426                                         {
1427                                                 pConfCallInfo->SetCallConnectTime(activeCall.GetCallConnectTime());
1428                                                 pConfCallInfo->SetCallNotificationTime(activeCall.GetCallNotificationTime());
1429                                         }
1430                                 }
1431                                 pConfCallInfo->SetCallHandle(joinedInfoNotification.id);
1432                                 pTelManager->__pActiveCallList->RemoveAll();
1433                                 //only one call in the list
1434                                 pTelManager->__pActiveCallList->Add(joinedInfoNotification.id, *pConfCallInfo);
1435                                 //notify listener that call is connected.
1436                                 pTelManager->__pEventListener->HandleConferenceCall(*pConfCallInfo);
1437                                 delete pCallList;
1438                                 pCallList = null;
1439                         }
1440                 }
1441         }
1442         else
1443         {
1444                 pTelManager->__pEventListener->HandleTelephonyError(ERROR_JOIN_FAILED);
1445         }
1446 }
1447
1448 void
1449 TelephonyManager::HandleSwapCallbackResponse(TapiHandle* pHandle, int callBackResult, void* pData, void* pUserData)
1450 {
1451         TelephonyManager* pTelManager = (TelephonyManager*) pUserData;
1452         if (callBackResult == TAPI_CAUSE_SUCCESS)
1453         {
1454                 IListT<AppCallInfo>* pCallList = pTelManager->__pActiveCallList->GetValuesN();
1455                 IListT<long>* pKeyList = pTelManager->__pActiveCallList->GetKeysN();
1456                 int callCount = pTelManager->__pActiveCallList->GetCount();
1457                 for (int index = 0; index < callCount; index++)
1458                 {
1459                         AppCallInfo* pTempCallInfo = new (std::nothrow) AppCallInfo();
1460                         pCallList->GetAt(index, *pTempCallInfo);
1461                         (pTempCallInfo->IsOnHold() == false) ? pTempCallInfo->SetOnHold(true) : pTempCallInfo->SetOnHold(false);
1462                         long callHandle;
1463                         pKeyList->GetAt(index, callHandle);
1464                         pTelManager->__pActiveCallList->SetValue(callHandle, *pTempCallInfo);
1465                 }
1466                 delete pCallList;
1467                 pCallList = null;
1468                 delete pKeyList;
1469                 pKeyList = null;
1470                 pCallList = pTelManager->__pActiveCallList->GetValuesN();
1471                 pTelManager->__pEventListener->HandleCallSwapOccured(*pCallList);
1472         }
1473         else
1474         {
1475                 pTelManager->__pEventListener->HandleTelephonyError(ERROR_SWAP_FAILED);
1476         }
1477 }
1478
1479 void
1480 TelephonyManager::HandleEndFromConferenceCallbackResponse(TapiHandle* pHandle, int callBackResult, void* pData, void* pUserData)
1481 {
1482         AppLogDebug("ENTER");
1483         //This callback comes if a single call is ended from Conference call.
1484         TelephonyManager* pTelManager = (TelephonyManager*) pUserData;
1485         bool isParticipantCallEnded = false;
1486
1487         if (callBackResult == TAPI_CAUSE_SUCCESS && pData != null)
1488         {
1489                 //fetch end call handle
1490                 TelCallEndCnf_t callEndNotification;
1491                 memcpy(&callEndNotification, pData, sizeof(TelCallEndCnf_t));
1492                 //Fetch conference call
1493                 AppCallInfo endConfCall;
1494                 bool isConferenceCallFound = false;
1495                 IListT<AppCallInfo>* pCallList = pTelManager->__pActiveCallList->GetValuesN();
1496                 int callCount = pCallList->GetCount();
1497                 for (int index = 0; index < callCount; index++)
1498                 {
1499                         pCallList->GetAt(index, endConfCall);
1500                         if (endConfCall.IsConferenceCall() == true)
1501                         {
1502                                 isConferenceCallFound = true;
1503                                 //Found the Conference call to be changed.
1504                                 break;
1505                         }
1506                 }
1507                 delete pCallList;
1508                 pCallList = null;
1509
1510                 //Identify the call to be ended and remove from list.
1511                 if (isConferenceCallFound == true)
1512                 {
1513                         isParticipantCallEnded = pTelManager->HandleParticipantEndedFromConference(callEndNotification.id, endConfCall);
1514                 }
1515         }
1516         else
1517         {
1518                 AppLog("TAPI Failed - %d", callBackResult);
1519         }
1520
1521         //Check if participant call or Conference call was not found, then show error
1522         if (isParticipantCallEnded == false)
1523         {
1524                 pTelManager->__pEventListener->HandleTelephonyError(ERROR_END_FROM_CONFERENCE_FAILED);
1525         }
1526         AppLogDebug("EXIT");
1527 }
1528
1529 bool
1530 TelephonyManager::HandleParticipantEndedFromConference(unsigned int participantCallHandle, AppCallInfo& conferenceCall)
1531 {
1532         AppLogDebug("ENTER");
1533         //to check if participant call was found and ended.
1534         bool isParticipantCallEnded = false;
1535         //Identify the call to be ended and remove from list.
1536         AppCallInfo callToBeEnded;
1537         IListT<AppCallInfo>* pCallerList = conferenceCall.GetCallerList();
1538         int callerCount = pCallerList->GetCount();
1539         for (int index = 0; index < callerCount; index++)
1540         {
1541                 pCallerList->GetAt(index, callToBeEnded);
1542                 if ((unsigned int)callToBeEnded.GetCallHandle()->ToLong() == participantCallHandle)
1543                 {
1544                         //Identify the call to be ended and remove from conference list
1545                         conferenceCall.RemoveCallFromCallerList(index);
1546                         //update its status to individual call before saving to database
1547                         callToBeEnded.SetConference(false);
1548                         SaveCallInfoToLogsDb(callToBeEnded);
1549                         isParticipantCallEnded = true;
1550                         break;
1551                 }
1552         }
1553
1554         if(isParticipantCallEnded == false)
1555         {
1556                 //participant call not found and not ended
1557                 return isParticipantCallEnded;
1558         }
1559
1560         unsigned int confCallHandle = (unsigned int)conferenceCall.GetCallHandle()->ToLong();
1561         //Check if last participant removed. If yes, switch to single active view
1562         if (conferenceCall.GetCallerListCount() == 1)
1563         {
1564                 AppCallInfo callFromList;
1565                 pCallerList = conferenceCall.GetCallerList();
1566                 pCallerList->GetAt(0, callFromList);
1567                 //construct a new single active call
1568                 AppCallInfo* pActiveCall = new (std::nothrow) AppCallInfo();
1569                 *pActiveCall = callFromList;
1570                 //update conference status and Hold status
1571                 pActiveCall->SetConference(false);
1572                 pActiveCall->SetOnHold(conferenceCall.IsOnHold());
1573
1574                 __pActiveCallList->Remove(confCallHandle);
1575                 __pActiveCallList->Add(pActiveCall->GetCallHandle()->ToLong(), *pActiveCall);
1576                 pActiveCall = null;
1577
1578                 //using the callConnected to switch to single active screen
1579                 //or update multiple active call screen
1580                 IListT<AppCallInfo>* pActiveCallList = __pActiveCallList->GetValuesN();
1581                 __pEventListener->HandleCallConnected(*pActiveCallList);
1582                 delete pActiveCallList;
1583                 pActiveCallList = null;
1584         }
1585         else
1586         {
1587                 AppCallInfo callFromList;
1588                 pCallerList = conferenceCall.GetCallerList();
1589                 pCallerList->GetAt(0, callFromList);
1590                 //construct a new conference call
1591                 AppCallInfo* pConfCallInfo = new (std::nothrow) AppCallInfo();
1592                 *pConfCallInfo = conferenceCall;
1593                 if (confCallHandle == participantCallHandle)
1594                 {
1595                         //Call Handle is same as conf call handle, so need to change conf call handle
1596                         __pActiveCallList->Remove(confCallHandle);
1597                         int newConfCallHandle = callFromList.GetCallHandle()->ToLong();
1598                         pConfCallInfo->SetCallHandle(newConfCallHandle);
1599                         __pActiveCallList->Add(newConfCallHandle, *pConfCallInfo);
1600                 }
1601                 else
1602                 {
1603                         __pActiveCallList->SetValue(confCallHandle, *pConfCallInfo);
1604                 }
1605                 __pEventListener->HandleConferenceChange();
1606         }
1607         AppLogDebug("EXIT");
1608         return isParticipantCallEnded;
1609 }
1610
1611 void
1612 TelephonyManager::HandleSplitFromConferenceCallbackResponse(TapiHandle* pHandle, int callBackResult, void* pData, void* pUserData)
1613 {
1614         TelephonyManager* pTelManager = (TelephonyManager*) pUserData;
1615         if (callBackResult == TAPI_CAUSE_SUCCESS && pData != null)
1616         {
1617                 TelCallSplitCnf_t callSplitNotification;
1618                 memcpy(&callSplitNotification, pData, sizeof(TelCallSplitCnf_t));
1619                 int confCallIndex = -1;
1620                 AppCallInfo endConfCall;
1621                 bool isConferenceCallFound = false;
1622
1623                 IListT<AppCallInfo>* pCallList = pTelManager->__pActiveCallList->GetValuesN();
1624                 int callCount = pCallList->GetCount();
1625                 for (int index = 0; index < callCount; index++)
1626                 {
1627                         pCallList->GetAt(index, endConfCall);
1628                         if (endConfCall.IsConferenceCall() == true)
1629                         {
1630                                 isConferenceCallFound = true;
1631                                 confCallIndex = index;
1632                                 //Found the Conference call to be ended.
1633                                 break;
1634                         }
1635                 }
1636
1637                 if (isConferenceCallFound == false)
1638                 {
1639                         delete pCallList;
1640                         pCallList = null;
1641                         return;
1642                 }
1643                 delete pCallList;
1644                 pCallList = null;
1645                 //Identify the call to be ended and remove from list on API success
1646                 AppCallInfo callToBeEnded;
1647                 pCallList = endConfCall.GetCallerList();
1648                 callCount = pCallList->GetCount();
1649                 for (int index = 0; index < callCount; index++)
1650                 {
1651                         pCallList->GetAt(index, callToBeEnded);
1652                         if ((unsigned int)callToBeEnded.GetCallHandle()->ToLong() == callSplitNotification.id)
1653                         {
1654                                 //Identified the call to be ended and remove from conference list
1655                                 //Add this to the active call list
1656                                 endConfCall.RemoveCallFromCallerList(index);
1657                                 break;
1658                         }
1659                 }
1660                 unsigned int confCallHandle = (unsigned int)endConfCall.GetCallHandle()->ToLong();
1661                 //Set the hold flags correctly and make the changes to the active call list
1662                 if (endConfCall.GetCallerListCount() == 1)
1663                 {
1664                         //Set hold for the other single call
1665                         // and add to the list
1666                         AppCallInfo callFromList;
1667                         pCallList = endConfCall.GetCallerList();
1668                         pCallList->GetAt(0, callFromList);
1669                         AppCallInfo* pHeldCall = new (std::nothrow) AppCallInfo();
1670                         *pHeldCall = callFromList;
1671                         pHeldCall->SetConference(false);
1672                         pHeldCall->SetOnHold(true);
1673                         pTelManager->__pActiveCallList->Remove(confCallHandle);
1674                         pTelManager->__pActiveCallList->Add(pHeldCall->GetCallHandle()->ToLong(), *pHeldCall);
1675                         pHeldCall = null;
1676                 }
1677                 else
1678                 {
1679                         //Set hold flag for conference call
1680                         endConfCall.SetOnHold(true);
1681                         AppCallInfo callFromList;
1682                         pCallList = endConfCall.GetCallerList();
1683                         pCallList->GetAt(0, callFromList);
1684
1685                         AppCallInfo* pConfCallInfo = new (std::nothrow) AppCallInfo();
1686                         *pConfCallInfo = endConfCall;
1687                         if (confCallHandle == callSplitNotification.id)
1688                         {
1689                                 //Call Handle is same as conf call handle.
1690                                 //Change conf call handle
1691                                 pTelManager->__pActiveCallList->Remove(confCallHandle);
1692                                 int tmpCallHandle = callFromList.GetCallHandle()->ToLong();
1693                                 pConfCallInfo->SetCallHandle(tmpCallHandle);
1694                                 pTelManager->__pActiveCallList->Add(callFromList.GetCallHandle()->ToLong(), *pConfCallInfo);
1695                         }
1696                         else
1697                         {
1698                                 pTelManager->__pActiveCallList->Remove(confCallHandle);
1699                                 pTelManager->__pActiveCallList->Add(confCallHandle, *pConfCallInfo);
1700                         }
1701                 }
1702                 //Add the new active call to active call list
1703                 AppCallInfo* pActiveCall = new (std::nothrow) AppCallInfo();
1704                 *pActiveCall = callToBeEnded;
1705                 pActiveCall->SetConference(false);
1706                 pActiveCall->SetOnHold(false);
1707                 pTelManager->__pActiveCallList->Remove(pActiveCall->GetCallHandle()->ToLong());
1708                 pTelManager->__pActiveCallList->Add(pActiveCall->GetCallHandle()->ToLong(), *pActiveCall);
1709                 pActiveCall = null;
1710                 //using the callConnected to switch to Multiple active screen
1711                 pCallList = pTelManager->__pActiveCallList->GetValuesN();
1712                 pTelManager->__pEventListener->HandleCallConnected(*pCallList);
1713                 pCallList = null;
1714         }
1715         else
1716         {
1717                 pTelManager->__pEventListener->HandleTelephonyError(ERROR_SPLIT_FROM_CONFERENCE_FAILED);
1718         }
1719 }
1720
1721 void
1722 TelephonyManager::HandleEndConferenceCallbackResponse(TapiHandle* pHandle, int callBackResult, void* pData, void* pUserData)
1723 {
1724         AppLog("ENTER");
1725         //This callback comes only if a conference call is ended by user.
1726         TelephonyManager* pTelManager = (TelephonyManager*) pUserData;
1727         if (callBackResult == TAPI_CAUSE_SUCCESS && pData != null)
1728         {
1729                 //fetch ended confCall details
1730                 result r = E_FAILURE;
1731                 AppCallInfo endConfCallInfo;
1732                 IListT<AppCallInfo>* pActiveCallList = pTelManager->__pActiveCallList->GetValuesN();
1733                 if(pActiveCallList != null && pActiveCallList->GetCount() > 0)
1734                 {
1735                         for (int index = 0; index < pActiveCallList->GetCount(); index++)
1736                         {
1737                                 r = pActiveCallList->GetAt(index, endConfCallInfo);
1738                                 if(r == E_SUCCESS && endConfCallInfo.IsConferenceCall() == true)
1739                                 {
1740                                         //conference call found.
1741                                         r = E_SUCCESS;
1742                                         break;
1743                                 }
1744                                 else
1745                                 {
1746                                         r = E_FAILURE;
1747                                 }
1748                         }
1749                 }
1750                 delete pActiveCallList;
1751                 pActiveCallList = null;
1752
1753                 //check if no conference call found, then return.
1754                 if(r == E_FAILURE)
1755                 {
1756                         return;
1757                 }
1758                 //remove the conference call handle from active call list to avoid any processing in HandleIdleCallback().
1759                 pTelManager->__pActiveCallList->Remove(endConfCallInfo.GetCallHandle()->ToLong());
1760                 //Save "End" Conf. call info to call log database
1761                 pTelManager->SaveCallInfoToLogsDb(endConfCallInfo);
1762
1763                 //check if the ended call was the last call and show notification to user
1764                 bool isLastCall = (pTelManager->__pActiveCallList->GetCount() == 0);
1765                 ArrayListT<AppCallInfo>* pCallList = null;
1766                 if (isLastCall)
1767                 {
1768                         pTelManager->__pSoundManager->SetlastEndedConferenceCall();
1769                         //stop sound session
1770                         pTelManager->__pSoundManager->StopSession();
1771                         //send empty call list to show dialer or call log screen
1772                         pCallList = new (std::nothrow) ArrayListT<AppCallInfo>();
1773                 }
1774                 else
1775                 {
1776                         //fetch active calls to show appropriate scene
1777                         pCallList = static_cast<ArrayListT<AppCallInfo>*>(pTelManager->__pActiveCallList->GetValuesN());
1778                 }
1779                 //notify listener that call is disconnected.
1780                 pTelManager->__pEventListener->HandleCallDisconnected(isLastCall, *pCallList);
1781                 delete pCallList;
1782                 pCallList = null;
1783         }
1784         else
1785         {
1786                 pTelManager->__pEventListener->HandleTelephonyError(ERROR_END_CALL_FAILED);
1787         }
1788         AppLog("EXIT");
1789 }
1790
1791 void
1792 TelephonyManager::HandleIdleCallBack(void* pData)
1793 {
1794         AppLogDebug("ENTER");
1795         //This callback comes when any type of calls are ended
1796         //We do NOT handle below scenarios here -
1797         //1) In incoming call scenarios, if we end any active calls - handled in "AcceptCall()".
1798         //2) Incoming call automatically blocked is handled in "AnswerAutoRejectCall()" and rejection by user scenarios are handled in "HandleRejectCallbackResponse()".
1799         //3) End conference call is handled in "HandleEndConferenceCallbackResponse()".
1800         //4) End Single Call from Conference call by user is handled in "HandleEndFromConferenceCallbackResponse()".
1801         //5) End Single Call from Conference call using eventInjector is diverted to "HandleParticipantEndedFromConference()".
1802         //BUT, we do handle below scenarios here -
1803         //1) "MISSED" incoming call scenario here i.e incoming call is rejected by other caller.
1804         //2) an "unconnected" dialed call is ended by caller or other party.
1805         //3) Any normal active calls(NOT conference calls) ended by user or by other party.
1806
1807         if(__pSoundManager->GetLastConferenceCall() == false)
1808         {
1809                 __pSoundManager->SetDisconnectTone();
1810         }
1811
1812         TelCallStatusIdleNoti_t idleNotification;
1813         memcpy(&idleNotification, pData, sizeof(TelCallStatusIdleNoti_t));
1814         //handle end call event, show next screen
1815         unsigned int endCallHandle = idleNotification.id;
1816
1817         //empty active call list or no dialed or incoming calls - ignore this event
1818         IListT<AppCallInfo>* pActiveCallList = __pActiveCallList->GetValuesN();
1819         if((pActiveCallList == null || pActiveCallList->GetCount() <= 0) && __pDialedCall == null && __pIncomingCall == null)
1820         {
1821                 delete pActiveCallList;
1822                 AppLogDebug("EXIT - no calls exist");
1823                 return;
1824         }
1825
1826         //Check if ended call was among conference caller list,
1827         //then divert event to "HandleParticipantEndedFromConference()"
1828         AppCallInfo confCallInfo;
1829         bool isConferenceCallChanged = false;
1830         for (int index = 0; (pActiveCallList != null && index < pActiveCallList->GetCount()); index++)
1831         {
1832                 //fetch conference call
1833                 result r = pActiveCallList->GetAt(index, confCallInfo);
1834                 if (r == E_SUCCESS && confCallInfo.IsConferenceCall() == true)
1835                 {
1836                         //Conference call found - check if ended call is a participant
1837                         isConferenceCallChanged = HandleParticipantEndedFromConference(endCallHandle, confCallInfo);
1838                         break;
1839                 }
1840         }
1841         delete pActiveCallList;
1842         pActiveCallList = null;
1843         if (isConferenceCallChanged == true)
1844         {
1845                 //end call event handled - conference call will now either remain as conf. call
1846                 //or become single active call, if it has only 1 participant left.
1847                 __pSoundManager->SetSoundMode(SOUND_MODE_VOICE);
1848                 AppLogDebug("isConferenceCallChanged == true");
1849                 return;
1850         }
1851
1852         //check if ended call was among the active call list and not a conference call
1853         AppCallInfo endCallInfo;
1854         result r = __pActiveCallList->GetValue(endCallHandle, endCallInfo);
1855         if (r == E_SUCCESS)
1856         {
1857                 bool isHandled = HandleEndNormalActiveCall(endCallInfo);
1858                 if (isHandled == true)
1859                 {
1860                         __pSoundManager->SetSoundMode(SOUND_MODE_VOICE);
1861                         return;
1862                 }
1863         }
1864
1865         //Check if dialed call is rejected by other party
1866         bool isDialedCallEnded = ((__pDialedCall != null)  && (__pDialedCall->GetCallHandle() != null) &&(((unsigned int)__pDialedCall->GetCallHandle()->ToLong()) == idleNotification.id));
1867         //Check if "missed" incoming call is ended
1868         bool isMissedIncomingCallEnded = (__pIncomingCall != null && ((unsigned int)__pIncomingCall->GetCallHandle()->ToLong() == idleNotification.id));
1869         if (isDialedCallEnded == true || isMissedIncomingCallEnded == true)
1870         {
1871                 //It comes here only if the ended call was either a "unconnected" dialed call or an "Missed" incoming call.
1872                 bool isLastCall = (__pActiveCallList->GetCount() == 0);
1873
1874                 ArrayListT<AppCallInfo>* pCallList = null;
1875                 //Check if dialed call was ended
1876                 if (isDialedCallEnded == true)
1877                 {
1878                         AppLogDebug("Dialed Call Ended");
1879                         //Call Ended is the dialed call
1880                         endCallInfo = *(__pDialedCall);
1881                         delete __pDialedCall;
1882                         __pDialedCall = null;
1883                 }
1884                 else
1885                 {
1886                         //Here, only "Missed" Incoming call ended by other caller is handled.
1887                         AppLogDebug("Missed Call Ended");
1888                         __pSoundManager->StopAlert();
1889                         endCallInfo = *(__pIncomingCall);
1890                         delete __pIncomingCall;
1891                         __pIncomingCall = null;
1892                         //update missed status
1893                         endCallInfo.SetCalllogType(CALL_LOG_TYPE_VOICE_MISSED_UNSEEN);
1894                 }
1895                 //save ended call to call log db.
1896                 SaveCallInfoToLogsDb(endCallInfo);
1897
1898                 //notify listener that call is disconnected.
1899                 if (isLastCall == true)
1900                 {
1901                         __pSoundManager->StopSession();
1902                         pCallList = new (std::nothrow) ArrayListT<AppCallInfo>();
1903                         pCallList->Construct(1);
1904                         if (isMissedIncomingCallEnded == false)
1905                         {
1906                                 //save to list to show EndCallForm
1907                                 pCallList->Add(endCallInfo);
1908                         }
1909                         __pSoundManager->GetTimer()->Cancel();
1910
1911                 }
1912                 else
1913                 {
1914                         pCallList = static_cast<ArrayListT<AppCallInfo>*>(__pActiveCallList->GetValuesN());
1915                 }
1916                 __pEventListener->HandleCallDisconnected(isLastCall, *pCallList);
1917                 delete pCallList;
1918                 pCallList = null;
1919         }
1920         __pSoundManager->SetSoundMode(SOUND_MODE_VOICE);
1921         AppLogDebug("EXIT");
1922 }
1923
1924 bool
1925 TelephonyManager::HandleEndNormalActiveCall(AppCallInfo& endCallInfo)
1926 {
1927         AppLogDebug("Enter");
1928         // This function gets called only from HandleIdleCallback(),
1929         // to handle disconnection of normal active calls.
1930         if (endCallInfo.IsConferenceCall() == false)
1931         {
1932                 //remove the call handle from active call list
1933                 __pActiveCallList->Remove(endCallInfo.GetCallHandle()->ToLong());
1934                 //check if the ended call was the last call and show notification to user
1935                 bool isLastCall = (__pActiveCallList->GetCount() == 0);
1936                 ArrayListT<AppCallInfo>* pCallList = null;
1937                 if (isLastCall)
1938                 {
1939                         //stop sound session
1940                         __pSoundManager->StopSession();
1941                         //save "End" CallInfo to list to show EndCallForm
1942                         pCallList = new (std::nothrow) ArrayListT<AppCallInfo>();
1943                         pCallList->Construct(1);
1944                         pCallList->Add(endCallInfo);
1945                 }
1946                 else
1947                 {
1948                         //fetch active calls to show appropriate scene
1949                         pCallList = static_cast<ArrayListT<AppCallInfo>*>(__pActiveCallList->GetValuesN());
1950                 }
1951
1952                 //Save "End" call info to call log database
1953                 SaveCallInfoToLogsDb(endCallInfo);
1954                 //notify listener that call is disconnected.
1955                 __pEventListener->HandleCallDisconnected(isLastCall, *pCallList);
1956                 delete pCallList;
1957                 pCallList = null;
1958                 return true;
1959         }
1960         return false;
1961 }
1962
1963 void
1964 TelephonyManager::HandleDialingCallBack(void* pData)
1965 {
1966         AppLogDebug("Enter");
1967         unsigned int tempHandle = 0;
1968         TelCallStatusDialingNoti_t dialingNotification;
1969         memcpy(&tempHandle, pData, sizeof(TS_UINT));
1970         dialingNotification.id = tempHandle;
1971         //check if callback is for different dialed call
1972         //Dont check for call handle, since this is the first time, we get call handle for a dialed call.
1973         if (__pDialedCall == null)
1974         {
1975                 AppLogDebug("__pDialedCall == null");
1976                 //construct new dialed call
1977                 __pDialedCall = new (std::nothrow) AppCallInfo();
1978
1979                 TelCallStatus_t callStatus;
1980                 int res = tel_get_call_status(__pTapiHandle, dialingNotification.id, &callStatus);
1981                 if (res == TAPI_CAUSE_SUCCESS)
1982                 {
1983                         //save phone number
1984                         String contactNumber(callStatus.pNumber);
1985                         __pDialedCall->SetContactNumber(contactNumber);
1986                         //set emergency state
1987                         if(callStatus.CallType == TAPI_CALL_TYPE_E911)
1988                         {
1989                                 __pDialedCall->SetEmergency(true);
1990                         }
1991                         else
1992                         {
1993                                 __pDialedCall->SetEmergency(false);
1994                         }
1995                         //save contact info
1996                         FetchContactInfoForNumber(__pDialedCall->GetContactNumber());
1997                         if (__pCachedContact != null)
1998                         {
1999                                 __pDialedCall->SetContactInfo(*(__pCachedContact));
2000                         }
2001                 }
2002         }
2003         //set call handle for dialed call
2004         __pDialedCall->SetCallHandle(dialingNotification.id);
2005         __pDialedCall->SetCalllogType(CALL_LOG_TYPE_VOICE_OUTGOING);
2006
2007         //set call notification time.
2008         long long startTime = 0;
2009         SystemTime::GetTicks(startTime);
2010         __pDialedCall->SetCallNotificationTime(startTime);
2011 }
2012
2013 void
2014 TelephonyManager::HandleActiveCallBack(void* pData)
2015 {
2016         // This callback comes whenever any new call is connected
2017         // Or, any "Held" call is activated (we ignore activation of "Held" calls).
2018         unsigned int newCallHandle = 0;
2019         TelCallStatusActiveNoti_t activeNotification;
2020         memcpy(&newCallHandle, pData, sizeof(TS_UINT));
2021         activeNotification.id = newCallHandle;
2022         IListT<AppCallInfo>* pCallList = __pActiveCallList->GetValuesN();
2023
2024         //Check if the "Held" call was activated, i.e it is already present in already activated calls list.
2025         bool toHandleEvent = true;
2026         for (int callIndex = 0; (callIndex < pCallList->GetCount() && toHandleEvent == true); callIndex++ )
2027         {
2028                 AppCallInfo tempCallInfo;
2029                 pCallList->GetAt(callIndex, tempCallInfo);
2030                 unsigned int tempCallHandle = tempCallInfo.GetCallHandle()->ToLong();
2031                 //Check if active callback came for "HandleJoinCallbackResponse"
2032                 //or for "UnHold Conference Call or normal call".
2033                 if(tempCallInfo.IsConferenceCall() == true)
2034                 {
2035                         if (tempCallHandle == activeNotification.id)
2036                         {
2037                                 toHandleEvent = false;
2038                         }
2039                         else
2040                         {
2041                                 //check individual participants of conf call
2042                                 IListT<AppCallInfo>* pConfCallList = tempCallInfo.GetCallerList();
2043                                 int confCallCount  = pConfCallList->GetCount();
2044                                 for (int callIndex = 0; (callIndex < confCallCount && toHandleEvent == true); callIndex++)
2045                                 {
2046                                         AppCallInfo confCallerInfo;
2047                                         pConfCallList->GetAt(callIndex, confCallerInfo);
2048                                         unsigned int confCallerHandle = confCallerInfo.GetCallHandle()->ToLong();
2049                                         if (confCallerHandle == activeNotification.id)
2050                                         {
2051                                                 toHandleEvent = false;
2052                                         }
2053                                 }
2054                         }
2055                 }
2056                 else if(tempCallHandle == activeNotification.id)
2057                 {
2058                         //If normal call is UnHold
2059                         toHandleEvent = false;
2060                 }
2061         }
2062
2063         //check if we need to handle this event.
2064         if(toHandleEvent == true)
2065         {
2066                 //Here it comes, only if either new dialed or incoming call was connected.
2067                 HandleCallConnected( activeNotification.id);
2068         }
2069         delete pCallList;
2070         pCallList = null;
2071 }
2072
2073 void
2074 TelephonyManager::HandleCallConnected(unsigned int connectedCallHandle)
2075 {
2076         //Here it comes, only if either new dialed or incoming call was connected.
2077         //This function should be called only from "HandleActiveCallback()".
2078         AppCallInfo* pConnectedCall = null;
2079         //to check if incoming call was connected
2080         bool isIncomingCallConnected = false;
2081
2082         __pSoundManager->SetConnectTone();
2083         //Check if dialed call is connected.
2084         if ((__pDialedCall != null) && (connectedCallHandle == (unsigned int)__pDialedCall->GetCallHandle()->ToLong()))
2085         {
2086                 pConnectedCall = __pDialedCall;
2087                 __pDialedCall = null;
2088         }
2089         //Check if connected call is incoming call.
2090         else if (__pIncomingCall != null && (connectedCallHandle == (unsigned int)__pIncomingCall->GetCallHandle()->ToLong()))
2091         {
2092                 pConnectedCall = __pIncomingCall;
2093                 __pIncomingCall = null;
2094                 isIncomingCallConnected = true;
2095         }
2096         else
2097         {
2098                 // this is just for safety. This scenario should never come.
2099                 // Otherwise Correct the code in some other function, if it comes here.
2100                 AppLogDebug("Error - Connected call was neither one of active calls nor it was dialed or incoming call");
2101                 //Construct a new CallInfo object for call
2102                 pConnectedCall = new (std::nothrow) AppCallInfo();
2103                 pConnectedCall->SetCallHandle(connectedCallHandle);
2104
2105                 TelCallStatus_t callStatus;
2106                 int res = tel_get_call_status(__pTapiHandle, connectedCallHandle, &callStatus);
2107                 if (res == TAPI_CAUSE_SUCCESS)
2108                 {
2109                         String contactNumber(callStatus.pNumber);
2110                         pConnectedCall->SetContactNumber(contactNumber);
2111                         //set emergency state
2112                         if(callStatus.CallType == TAPI_CALL_TYPE_E911)
2113                         {
2114                                 pConnectedCall->SetEmergency(true);
2115                         }
2116                         else
2117                         {
2118                                 pConnectedCall->SetEmergency(false);
2119                         }
2120                         //set call notification time
2121                         long long startTime = 0;
2122                         SystemTime::GetTicks(startTime);
2123                         pConnectedCall->SetCallNotificationTime(startTime);
2124                         if (callStatus.bMoCall == true)
2125                         {
2126                                 pConnectedCall->SetCalllogType(CALL_LOG_TYPE_VOICE_OUTGOING);
2127                         }
2128                         else
2129                         {
2130                                 pConnectedCall->SetCalllogType(CALL_LOG_TYPE_VOICE_INCOMING);
2131                                 isIncomingCallConnected = true;
2132                         }
2133                 }
2134                 //delete any dialed or incoming call objects
2135                 delete __pDialedCall;
2136                 __pDialedCall = null;
2137                 delete __pIncomingCall;
2138                 __pIncomingCall = null;
2139         }
2140
2141         //fetch contact info for connected call & it is not a hidden call
2142         if (pConnectedCall->GetContactInfo() == null && pConnectedCall->GetContactNumber().IsEmpty() == false)
2143         {
2144                 FetchContactInfoForNumber(pConnectedCall->GetContactNumber());
2145                 if (__pCachedContact != null)
2146                 {
2147                         pConnectedCall->SetContactInfo(*(__pCachedContact));
2148                 }
2149         }
2150         //set Call connect time for newly connected call
2151         long long startTime = 0;
2152         SystemTime::GetTicks(startTime);
2153         pConnectedCall->SetCallConnectTime(startTime);
2154         if(GetCurrentCallCount() == 0)
2155         {
2156                 __pSoundManager->SetMinuteReminderTone();
2157         }
2158
2159
2160         //transfer ownership to Active calls list
2161         __pActiveCallList->Add(connectedCallHandle, *(pConnectedCall));
2162         pConnectedCall = null;
2163
2164         //notify listener that call is connected.
2165         IListT<AppCallInfo>* pCallList = __pActiveCallList->GetValuesN();
2166         __pSoundManager->SetSoundMode(SOUND_MODE_VOICE);
2167         __pEventListener->HandleCallConnected(*pCallList);
2168         if (isIncomingCallConnected == true)
2169         {
2170                 __pSoundManager->StopAlert();
2171         }
2172         delete pCallList;
2173         pCallList = null;
2174 }
2175
2176 bool
2177 TelephonyManager::CheckIncomingCallToBeRejected(AppCallInfo* pIncomingCallInfo)
2178 {
2179         AppLogDebug("Enter");
2180         int callHandle = pIncomingCallInfo->GetCallHandle()->ToLong();
2181         String contactNumber(L"");
2182         contactNumber.Append(pIncomingCallInfo->GetContactNumber());
2183         //Check if "reject unknown calls" is set and contact number is not present in AddressBook
2184         //or if contact number is blacklisted
2185         if (((__pSettingsManager->GetUnknownRejectStatus() == true) && (pIncomingCallInfo->GetContactInfo() == null))
2186                         || (__pSettingsManager->IsCallToBeRejected(contactNumber) == true))
2187         {
2188                 AnswerAutoRejectCall(callHandle);
2189                 return true;
2190         }
2191         return false;
2192 }
2193
2194 void
2195 TelephonyManager::HandleCallback(TapiHandle* pHandle, const char* pNotiId, void* pData, void* pUserData)
2196 {
2197         AppLogDebug("Enter");
2198         unsigned int tempHandle = 0;
2199         TelephonyManager* pTelManager = (TelephonyManager*) pUserData;
2200         if (pTelManager->__pSoundManager == null)
2201         {
2202                 AppLog("Creating Sound Manager");
2203                 pTelManager->__pSoundManager = new (std::nothrow) SoundManager();
2204         }
2205         //Handle telephony events
2206         if (strcmp(pNotiId, TAPI_NOTI_VOICE_CALL_STATUS_IDLE) == 0)
2207         {
2208                 pTelManager->HandleIdleCallBack(pData);
2209         }
2210         else if (strcmp(pNotiId, TAPI_NOTI_VOICE_CALL_STATUS_ACTIVE) == 0)
2211         {
2212                 pTelManager->__pSoundManager->StartSession();
2213                 pTelManager->HandleActiveCallBack(pData);
2214         }
2215         else if (strcmp(pNotiId, TAPI_NOTI_VOICE_CALL_STATUS_DIALING) == 0)
2216         {
2217                 pTelManager->HandleDialingCallBack(pData);
2218         }
2219         else
2220         {
2221                 memcpy(&tempHandle, pData, sizeof(TS_UINT));
2222         }
2223 }
2224
2225 AppCallInfo*
2226 TelephonyManager::GetConferenceCallInfoN(void)
2227 {
2228         AppCallInfo* pConfCallInfo = null;
2229
2230         IListT<AppCallInfo>* pCallList = __pActiveCallList->GetValuesN();
2231         int callCount = pCallList->GetCount();
2232         for (int index = 0; index < callCount; index++)
2233         {
2234                 AppCallInfo callInfo;
2235                 pCallList->GetAt(index, callInfo);
2236                 if (callInfo.IsConferenceCall() == true)
2237                 {
2238                         pConfCallInfo = new (std::nothrow) AppCallInfo();
2239                         *pConfCallInfo = callInfo;
2240                         //Found the Conference call
2241                         break;
2242                 }
2243         }
2244         delete pCallList;
2245         pCallList = null;
2246
2247         return pConfCallInfo;
2248 }
2249
2250 IListT<AppCallInfo>*
2251 TelephonyManager::GetCallListN(void)
2252 {
2253         ArrayListT<AppCallInfo>* pCallList = null;
2254         if (__pActiveCallList != null)
2255         {
2256                 pCallList = static_cast<ArrayListT<AppCallInfo>*>(__pActiveCallList->GetValuesN());
2257         }
2258         return pCallList;
2259 }
2260
2261 int
2262 TelephonyManager::GetCurrentCallCount(void)
2263 {
2264         if (__pActiveCallList != null)
2265         {
2266                 return __pActiveCallList->GetCount();
2267         }
2268         return 0;
2269 }
2270
2271 void
2272 TelephonyManager::StartAlert(AppCallInfo& incomingCallInfo)
2273 {
2274         String contactRingTone(L"");
2275         String contactNumber = incomingCallInfo.GetContactNumber();
2276         //check if not hidden call
2277         if(contactNumber.IsEmpty() == false)
2278         {
2279                 //fetch contact info from Db
2280                 Contact* foundContact = GetContactN(contactNumber);
2281                 if(foundContact != null)
2282                 {
2283                         //fetch custom ringtone for contact
2284                         result r = foundContact->GetValue(CONTACT_PROPERTY_ID_RINGTONE, contactRingTone);
2285                         //Now check if there is a group ring tone
2286                         if(contactRingTone.IsEmpty() == true)
2287                         {
2288                                 IList* pCategoryList = __pAddressBook->GetCategoriesByContactN(foundContact->GetRecordId());
2289                                 if(pCategoryList != null && pCategoryList->GetCount() > 0)
2290                                 {
2291                                         Category* pCategory = static_cast<Category*>(pCategoryList->GetAt(0));
2292                                         contactRingTone = pCategory->GetRingtonePath();
2293                                 }
2294                         }
2295                         AppLog("ringtone fetched - r = %d", r);
2296                         delete foundContact;
2297                         foundContact = null;
2298                 }
2299         }
2300         __pSoundManager->StartAlert(contactRingTone);
2301 }
2302
2303 void
2304 TelephonyManager::StopAlert(void)
2305 {
2306         __pSoundManager->StopAlert();
2307 }
2308
2309 result
2310 TelephonyManager::CheckValidTelePhoneNumber(const String& contactNumber)
2311 {
2312         result r = E_SUCCESS;
2313         if (contactNumber.GetLength() > TAPI_CALL_DIALDIGIT_LEN_MAX)
2314         {
2315                 r = E_FAILURE;
2316         }
2317         //TODO: check if valid phone number else return error message
2318         return r;
2319 }
2320
2321 result
2322 TelephonyManager::CheckIfMOCallIsPossible()
2323 {
2324         result r = E_SUCCESS;
2325
2326         //Check modem power status
2327         int modemStatus = 0;
2328         int errorCode = tel_check_modem_power_status(__pTapiHandle, &modemStatus);
2329         if (errorCode != TAPI_API_SUCCESS || modemStatus == TAPI_PHONE_POWER_STATUS_OFF
2330                         || modemStatus == TAPI_PHONE_POWER_STATUS_ERROR)
2331         {
2332                 r = E_FAILURE;
2333         }
2334         else
2335         {
2336                 TelSimCardStatus_t simStatus;
2337                 int simChangedStatus;
2338                 //fetch sim initialization status
2339                 int errorCode = tel_get_sim_init_info(__pTapiHandle, &simStatus, &simChangedStatus);
2340                 if (errorCode != TAPI_API_SUCCESS)
2341                 {
2342                         r = E_FAILURE;
2343                 }
2344                 else
2345                 {
2346                         switch (simStatus)
2347                         {
2348                         case TAPI_SIM_STATUS_SIM_INIT_COMPLETED: // Sim Initialization ok
2349                                 r = E_SUCCESS;
2350                                 break;
2351
2352                         case TAPI_SIM_STATUS_UNKNOWN: //initial state
2353                         case TAPI_SIM_STATUS_CARD_NOT_PRESENT: //Card not present
2354                         case TAPI_SIM_STATUS_CARD_REMOVED: //Card removed
2355                         case TAPI_SIM_STATUS_CARD_ERROR: // Bad card / On the fly, SIM gone bad
2356                                 //TODO: might want to set different error code, to give proper message to user
2357                                 r = E_FAILURE;
2358                                 break;
2359                         default:
2360                                 r = E_FAILURE;
2361                                 break;
2362                         }
2363                 }
2364         }
2365         return r;
2366 }
2367
2368 bool
2369 TelephonyManager::CheckIfMOCallIsEmergency(const String& contactNumber, bool isSimInitialized)
2370 {
2371         //TODO: extract actual telephone number from contactNumber
2372         //by deleting prefix,'P','W', etx.
2373
2374         bool isEmergency = false;
2375         //conversion "contactNumber" to char*
2376         const wchar_t* pContact = contactNumber.GetPointer();
2377         int len = contactNumber.GetLength() + 1;
2378         char* pNumber = new (std::nothrow) char[len];
2379         wcstombs(pNumber, pContact, len);
2380
2381         if(isSimInitialized)
2382         {
2383                 //used to get Ecc information for 2G and 3G.
2384                 TelSimEccList_t simEccList;
2385                 memset(&simEccList, 0x00, sizeof(TelSimEccList_t));
2386                 //Check if given number matches the sim card's emergency numbers
2387                 int errorCode = tel_get_sim_ecc(__pTapiHandle, &simEccList);
2388                 if (errorCode == TAPI_API_SUCCESS && simEccList.ecc_count > 0)
2389                 {
2390                         for (int index = 0; index < simEccList.ecc_count; index++)
2391                         {
2392                                 if ((strcmp(pNumber, simEccList.list[index].number) == 0))
2393                                 {
2394                                         isEmergency = true;
2395                                 }
2396                         }
2397                 }
2398         }
2399         else
2400         {
2401                 //TODO: check if we need to also check SOS call numbers, if sim not present.
2402         }
2403
2404         delete[] pNumber;
2405         pNumber = null;
2406         return isEmergency;
2407 }
2408
2409 result
2410 TelephonyManager::FetchContactInfoForNumber(const String& phoneNumberStr)
2411 {
2412         result r = E_FAILURE;
2413
2414         //delete previously cached data
2415         if (__pCachedContact != null)
2416         {
2417                 delete __pCachedContact;
2418                 __pCachedContact = null;
2419         }
2420
2421         //Searches contacts by phone number.
2422         IList* pContactList = __pAddressBook->SearchContactsByPhoneNumberN(phoneNumberStr);
2423         if (pContactList == null || IsFailed(GetLastResult()))
2424         {
2425                 return r;
2426         }
2427
2428         //Fetch the contact's info to be displayed
2429         IEnumerator* pContactEnum = pContactList->GetEnumeratorN();
2430         while ((E_SUCCESS == pContactEnum->MoveNext()) && (__pCachedContact == null))
2431         {
2432                 Contact* pContact = static_cast<Contact*>(pContactEnum->GetCurrent());
2433
2434                 IList* pPhoneNumberList = pContact->GetValuesN(CONTACT_MPROPERTY_ID_PHONE_NUMBERS);
2435                 if (pPhoneNumberList != null)
2436                 {
2437                         IEnumerator* pPhoneEnum = pPhoneNumberList->GetEnumeratorN();
2438                         while (E_SUCCESS == pPhoneEnum->MoveNext())
2439                         {
2440                                 PhoneNumber* pPhoneNumber = (PhoneNumber*) pPhoneEnum->GetCurrent();
2441                                 //Check if this is the correct contact
2442                                 if (pPhoneNumber->GetPhoneNumber().Equals(phoneNumberStr))
2443                                 {
2444                                         //save newly fetched contact info.
2445                                         __pCachedContact = new (std::nothrow) Contact(*pContact);
2446                                         r = E_SUCCESS;
2447                                         break;
2448                                 }
2449                         }
2450                         delete pPhoneEnum;
2451                         pPhoneNumberList->RemoveAll(true);
2452                         delete pPhoneNumberList;
2453                 }
2454         }
2455         delete pContactEnum;
2456         pContactList->RemoveAll(true);
2457         delete pContactList;
2458
2459         return r;
2460 }
2461
2462 Contact*
2463 TelephonyManager::GetContactN(const String& phoneNumber)
2464 {
2465         result r = FetchContactInfoForNumber(phoneNumber);
2466         if (!IsFailed(r))
2467         {
2468                 return new (std::nothrow) Contact(*__pCachedContact);
2469         }
2470         return null;
2471 }
2472
2473 AppCallInfo*
2474 TelephonyManager::FetchIncomingCallHandleN(const String& callHandle, const String& contactNumber)
2475 {
2476         if(__pIncomingCall != null)
2477         {
2478                 delete __pIncomingCall;
2479                 __pIncomingCall = null;
2480         }
2481
2482         if(callHandle.IsEmpty() == false)
2483         {
2484                 int incomingHandle;
2485                 Integer::Parse(callHandle,incomingHandle);
2486                 //This API call is synchronous
2487                 TelCallStatus_t callStatus;
2488                 int errCode = tel_get_call_status(__pTapiHandle, incomingHandle, &callStatus);
2489                 if (errCode != TAPI_API_SUCCESS)
2490                 {
2491                         AppLogDebug("tel_get_call_status failed");
2492                         return null;
2493                 }
2494                 //construct incoming call info object
2495                 __pIncomingCall = new (std::nothrow) AppCallInfo();
2496                 __pIncomingCall->SetCallHandle(incomingHandle);
2497
2498                 //contact number
2499                 String phoneNumber(contactNumber);
2500                 if(phoneNumber.IsEmpty() == true)
2501                 {
2502                         phoneNumber.Append(callStatus.pNumber);
2503                 }
2504                 __pIncomingCall->SetContactNumber(phoneNumber);
2505                 //set emergency state
2506                 if(callStatus.CallType == TAPI_CALL_TYPE_E911)
2507                 {
2508                         __pIncomingCall->SetEmergency(true);
2509                 }
2510                 else
2511                 {
2512                         __pIncomingCall->SetEmergency(false);
2513                 }
2514                 //set start time, when call is connected
2515                 long long startTime = 0;
2516                 SystemTime::GetTicks(startTime);
2517                 __pIncomingCall->SetCallNotificationTime(startTime);
2518                 __pIncomingCall->SetCalllogType(CALL_LOG_TYPE_VOICE_INCOMING);
2519         }
2520         else
2521         {
2522                 //TODO: This 'else' block can be removed once AppControl request API is stabilized.
2523                 //This API call is synchronous and 'HandleIncomingCallStatusCallBack' is called for each active call.
2524                 int errCode = tel_get_call_status_all(__pTapiHandle, &HandleIncomingCallStatusCallBack, this);
2525                 if (errCode != TAPI_API_SUCCESS)
2526                 {
2527                         return null;
2528                 }
2529         }
2530
2531         if(__pIncomingCall != null)
2532         {
2533                 //set call notification time
2534                 long long startTime = 0;
2535                 SystemTime::GetTicks(startTime);
2536                 __pIncomingCall->SetCallNotificationTime(startTime);
2537
2538                 if(__pIncomingCall->GetContactNumber().IsEmpty() == false)
2539                 {
2540                         //fetch contact info
2541                         FetchContactInfoForNumber(__pIncomingCall->GetContactNumber());
2542                         if (__pCachedContact != null)
2543                         {
2544                                 __pIncomingCall->SetContactInfo(*__pCachedContact);
2545                         }
2546                 }
2547
2548                 //construct a new callinfo object to pass its ownership to caller.
2549                 AppCallInfo* pNewIncomingCall = new (std::nothrow) AppCallInfo();
2550                 *pNewIncomingCall = *__pIncomingCall;
2551                 return pNewIncomingCall;
2552         }
2553         //return null, if no incoming call found
2554         return null;
2555 }
2556
2557 void
2558 TelephonyManager::HandleIncomingCallStatusCallBack(TelCallStatus_t* pCallStatus, void* pUserData)
2559 {
2560         TelephonyManager* pTelManager = (TelephonyManager*) pUserData;
2561         if (pCallStatus != null && pCallStatus->bMoCall == false
2562                         && ((pCallStatus->CallState == TAPI_CALL_STATE_INCOMING)
2563                                         || (pCallStatus->CallState == TAPI_CALL_STATE_WAITING)))
2564         {
2565                 //construct incoming call details
2566                 pTelManager->__pIncomingCall = new (std::nothrow) AppCallInfo();
2567                 pTelManager->__pIncomingCall->SetCallHandle(pCallStatus->CallHandle);
2568                 //contact number
2569                 String contactNumber(pCallStatus->pNumber);
2570                 pTelManager->__pIncomingCall->SetContactNumber(contactNumber);
2571                 //set emergency state
2572                 if(pCallStatus->CallType == TAPI_CALL_TYPE_E911)
2573                 {
2574                         pTelManager->__pIncomingCall->SetEmergency(true);
2575                 }
2576                 else
2577                 {
2578                         pTelManager->__pIncomingCall->SetEmergency(false);
2579                 }
2580
2581                 pTelManager->__pIncomingCall->SetCalllogType(CALL_LOG_TYPE_VOICE_INCOMING);
2582         }
2583 }
2584
2585 void
2586 TelephonyManager::SaveCallInfoToLogsDb(AppCallInfo& endCallInfo)
2587 {
2588         if (endCallInfo.IsConferenceCall() == false)
2589         {
2590                 //single active call - Add call ended to call log database
2591                 __pCalllogMgr->AddCallogInfoToDatabase(&endCallInfo);
2592         }
2593         else
2594         {
2595                 //Conference call
2596                 int confCallCount = endCallInfo.GetCallerListCount();
2597                 IListT<AppCallInfo>* pParticipantList = endCallInfo.GetCallerList();
2598                 for (int index = 0; index < confCallCount; index++)
2599                 {
2600                         AppCallInfo participantInfo;
2601                         if (pParticipantList->GetAt(index, participantInfo) == E_SUCCESS)
2602                         {
2603                                 //Add call ended to call log database
2604                                 __pCalllogMgr->AddCallogInfoToDatabase(&participantInfo);
2605                         }
2606                 }
2607         }
2608 }
2609
2610 void
2611 TelephonyManager::OnTelephonyNetworkStatusChanged(const NetworkStatus& networkStatus)
2612 {
2613         if(networkStatus.IsCallServiceAvailable() == false)
2614         {
2615                 EndAllCalls();
2616         }
2617 }
2618
2619 bool
2620 TelephonyManager::IsIncomingorDialingCallPresent(void)
2621 {
2622         //returns false, if incoming call or dialed call is present.
2623         return ((__pIncomingCall != null) || (__pDialedCall != null));
2624 }