src/CallPresentationModel.cpp

   1 //
   2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Flora License, Version 1.1 (the License);
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //     http://floralicense.org/license/
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an AS IS BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15 //
  16
  17 /**
  18  * @file        CallCallPresentationModel.cpp
  19  * @brief       Call Presentation model class
  20  */
  21 #include <FApp.h>
  22 #include <FUi.h>
  23 #include <FMedia.h>
  24 #include "CallApp.h"
  25 #include "CallAppControlRequestMgr.h"
  26 #include "CallActiveCallForm.h"
  27 #include "CallInfo.h"
  28 #include "CallPresentationModel.h"
  29 #include "CallSettingsPresentationModel.h"
  30 #include "CallConfCallerListForm.h"
  31 #include "CallTelephonyManager.h"
  32 #include "CallSceneRegister.h"
  33 #include "CallTypes.h"
  34
  35 using namespace Tizen::Base;
  36 using namespace Tizen::Base::Collection;
  37 using namespace Tizen::App;
  38 using namespace Tizen::Graphics;
  39 using namespace Tizen::Media;
  40 using namespace Tizen::Social;
  41 using namespace Tizen::Ui::Scenes;
  42 using namespace Tizen::Telephony;
  43 using namespace Tizen::Base::Utility;
  44 using namespace Tizen::Messaging;
  45
  46 CallPresentationModel* CallPresentationModel::__pInstance = null;
  47
  48 CallPresentationModel::CallPresentationModel(void)
  49 {
  50         __pTelephonyMgr = null;
  51         __pTelEventListener = null;
  52         __pSettingsPresentor = null;
  53         __isMessageAppControlRunning = false;
  54         __isDialAppControlRunning = false;
  55         __pAppControlMgr = null;
  56         __pNetworkManager = null;
  57         __psimStateManager = null;
  58         __psimInfo = null;
  59         __pSmsManager = null;
  60         __isMessageSendInProgress = false;
  61 }
  62
  63 CallPresentationModel::~CallPresentationModel(void)
  64 {
  65         __pTelephonyMgr = null;
  66         __pSettingsPresentor = null;
  67         __pAppControlMgr =null;
  68         if(__pNetworkManager != null)
  69         {
  70                 delete __pNetworkManager;
  71                 __pNetworkManager = null;
  72         }
  73         if(__psimStateManager != null)
  74         {
  75                 delete __psimStateManager;
  76                 __psimStateManager = null;
  77         }
  78         if(__psimInfo != null)
  79         {
  80                 delete __psimInfo;
  81                 __psimInfo = null;
  82         }
  83         if(__pSmsManager != null)
  84         {
  85                 delete __pSmsManager;
  86                 __pSmsManager = null;
  87         }
  88 }
  89
  90 void
  91 CallPresentationModel::CreateInstance(void)
  92 {
  93         __pInstance = new (std::nothrow) CallPresentationModel();
  94         result r = __pInstance->Construct();
  95         if(IsFailed(r))
  96         {
  97                 delete __pInstance;
  98                 __pInstance = null;
  99                 return;
 100         }
 101
 102         std::atexit(DestroyInstance);
 103 }
 104
 105 CallPresentationModel*
 106 CallPresentationModel::GetInstance(void)
 107 {
 108         if (__pInstance == null)
 109         {
 110                 CreateInstance();
 111         }
 112         return __pInstance;
 113 }
 114
 115 void
 116 CallPresentationModel::DestroyInstance(void)
 117 {
 118         if (__pInstance != null)
 119         {
 120                 delete __pInstance;
 121                 __pInstance = null;
 122         }
 123 }
 124
 125 result
 126 CallPresentationModel::Construct(void)
 127 {
 128         //Fetch Telephony Manager
 129         __pTelephonyMgr = TelephonyManager::GetInstance(this);
 130         __pSettingsPresentor = SettingsPresentationModel::GetInstance();
 131         __pAppControlMgr = CallAppControlRequestMgr::GetInstance();
 132         __pNetworkManager = new (std::nothrow)NetworkManager();
 133         __pNetworkManager->Construct(null);
 134         GetSimInfo();
 135         return E_SUCCESS;
 136 }
 137
 138 void
 139 CallPresentationModel::SetTelEventListener(ITelephonyEventListener* pTelEventListener)
 140 {
 141         //set form as telephony event listener
 142         __pTelEventListener = pTelEventListener;
 143 }
 144
 145 bool
 146 CallPresentationModel::IfNumberEndsWithHash(Tizen::Base::String& phoneNumber)
 147 {
 148         String phoneNumberEndingWithHash(L"#$");
 149         RegularExpression checkHash;
 150         checkHash.Construct(phoneNumberEndingWithHash);
 151         bool endsWithHash = checkHash.Match(phoneNumber,false);
 152         if(endsWithHash == true)
 153         {
 154                 return true;
 155         }
 156         return false;
 157 }
 158
 159 void
 160 CallPresentationModel::DialCall(String& contactNumber, bool isEmergency)
 161 {
 162         int errorCode = ERROR_NONE;
 163         bool isCallServiceAvailable = false;
 164         bool numberEndsWithHash = false;
 165         NetworkStatus networkStatus;
 166         result r;
 167         //Check if Telephony Manager is initialized
 168         TryCatch(__pTelephonyMgr != null, (errorCode = ERROR_TAPI_INIT_FAILED), "TAPI initialization failed");
 169
 170         //check if phone is in flight mode
 171         if(__pSettingsPresentor != null && __pSettingsPresentor->GetFlightModeStatus() == true)
 172         {
 173                 __pTelEventListener->HandleTelephonyError(ERROR_FLIGHT_MODE_SET);
 174                 return;
 175         }
 176         //Check if dialing a call is possible - Check if sim is available
 177         if (IsSimAvailable() == false)
 178         {
 179                 __pTelEventListener->HandleTelephonyError(ERROR_CODE_SIM_INITIALIZATION_FAILED);
 180                 return ;
 181         }
 182
 183         //fetch call service status
 184         if(__pNetworkManager != null)
 185         {
 186                 r = __pNetworkManager->GetNetworkStatus(networkStatus);
 187                 if (r == E_SUCCESS)
 188                 {
 189                         isCallServiceAvailable = networkStatus.IsCallServiceAvailable();
 190                 }
 191         }
 192
 193
 194         if (isCallServiceAvailable == false)
 195         {
 196                 __pTelEventListener->HandleTelephonyError(ERROR_DIAL_FAILED);
 197                 return ;
 198         }
 199         // check if GPRS number
 200         numberEndsWithHash = IfNumberEndsWithHash(contactNumber);
 201         if(numberEndsWithHash == true)
 202         {
 203                 __pTelEventListener->HandleTelephonyError(ERROR_USSD_NUMBER);
 204                 return ;
 205         }
 206
 207         //setup outgoing call
 208         errorCode = __pTelephonyMgr->SetupMoCall(contactNumber, isEmergency);
 209         TryCatch(errorCode == ERROR_NONE,,"Error occurred while setup MO call");
 210         if(__pSettingsPresentor != null)
 211         {
 212                 __pSettingsPresentor->SetCallState(CALL_STATE_CALL_VOICE_CONNECTING);
 213         }
 214         return;
 215
 216 CATCH:
 217         __pTelEventListener->HandleTelephonyError(errorCode);
 218 }
 219
 220 void
 221 CallPresentationModel::EndActiveCall(Long callHandle)
 222 {
 223         if(__pTelephonyMgr != null)
 224         {
 225                 __pTelephonyMgr->EndActiveCall(callHandle);
 226         }
 227 }
 228
 229 void
 230 CallPresentationModel::EndDialingCall(String& contactNumber)
 231 {
 232         if(__pTelephonyMgr != null)
 233         {
 234                 __pTelephonyMgr->EndDialingCall(contactNumber);
 235         }
 236 }
 237
 238 bool
 239 CallPresentationModel::EndConferenceCall(void)
 240 {
 241         result r = __pTelephonyMgr->EndConferenceCall();
 242         if (IsFailed(r))
 243         {
 244                 //TODO: send proper error code
 245                 __pTelEventListener->HandleTelephonyError(ERROR_GENERAL);
 246                 return false;
 247         }
 248         return true;
 249 }
 250
 251 void
 252 CallPresentationModel::EndAllCall(void)
 253 {
 254         if(__pTelephonyMgr != null)
 255         {
 256                 __pTelephonyMgr->EndAllCalls();
 257         }
 258 }
 259 bool
 260 CallPresentationModel::HoldCall(Tizen::Base::Long callHandle)
 261 {
 262         result r = __pTelephonyMgr->HoldCall(callHandle, true);
 263         return (!IsFailed(r));
 264 }
 265
 266 bool
 267 CallPresentationModel::UnHoldCall(Tizen::Base::Long callHandle)
 268 {
 269         result r = __pTelephonyMgr->HoldCall(callHandle, false);
 270         return (!IsFailed(r));
 271 }
 272
 273 bool
 274 CallPresentationModel::HoldConferenceCall(void)
 275 {
 276         result r = __pTelephonyMgr->HoldConferenceCall(true);
 277         return (!IsFailed(r));
 278 }
 279
 280 bool
 281 CallPresentationModel::ActivateConferenceCall(void)
 282 {
 283         result r = __pTelephonyMgr->HoldConferenceCall(false);
 284         return (!IsFailed(r));
 285 }
 286
 287 void
 288 CallPresentationModel::JoinCall(void)
 289 {
 290         result r = __pTelephonyMgr->JoinCall();
 291         if (IsFailed(r))
 292         {
 293                 __pTelEventListener->HandleTelephonyError(ERROR_JOIN_FAILED);
 294         }
 295 }
 296
 297 void
 298 CallPresentationModel::SwapCalls(void)
 299 {
 300         result r = __pTelephonyMgr->SwapCalls();
 301         if (IsFailed(r))
 302         {
 303                 __pTelEventListener->HandleTelephonyError(ERROR_SWAP_FAILED);
 304         }
 305 }
 306
 307 bool
 308 CallPresentationModel::SetMuteStatus(bool setMute)
 309 {
 310         result r = __pTelephonyMgr->SetMuteStatus(setMute);
 311         return (!IsFailed(r));
 312 }
 313
 314 bool
 315 CallPresentationModel::IsCallMuted(void)
 316 {
 317         return __pTelephonyMgr->IsCallMuted();
 318 }
 319
 320 bool
 321 CallPresentationModel::SetSpeakerStatus(bool setSpeaker)
 322 {
 323         result r = __pTelephonyMgr->SetSpeakerStatus(setSpeaker);
 324         return (!IsFailed(r));
 325 }
 326
 327 bool
 328 CallPresentationModel::IsSpeakerOn(void)
 329 {
 330         return __pTelephonyMgr->IsSpeakerOn();
 331 }
 332 void
 333 CallPresentationModel::SendDTMFSignal(String& textToBeSent)
 334 {
 335         __pTelephonyMgr->SendCallDTMF(textToBeSent);
 336 }
 337
 338 AppCallInfo*
 339 CallPresentationModel::GetConferenceCallInfoN(void)
 340 {
 341         return __pTelephonyMgr->GetConferenceCallInfoN();
 342 }
 343
 344 bool
 345 CallPresentationModel::SplitFromConference(SplitConfCallerCmdIds splitCallerCmdId, IListT<AppCallInfo>* pConfCallList)
 346 {
 347         int callIndex = -1;
 348         AppCallInfo callToBeSpli;
 349         switch (splitCallerCmdId)
 350         {
 351         case IDA_SPLIT_CALLER1:
 352                 callIndex = 0;
 353                 break;
 354
 355         case IDA_SPLIT_CALLER2:
 356                 callIndex = 1;
 357                 break;
 358
 359         case IDA_SPLIT_CALLER3:
 360                 callIndex = 2;
 361                 break;
 362
 363         case IDA_SPLIT_CALLER4:
 364                 callIndex = 3;
 365                 break;
 366
 367         case IDA_SPLIT_CALLER5:
 368                 callIndex = 4;
 369                 break;
 370
 371         default:
 372         break;
 373         }
 374
 375         result r = pConfCallList->GetAt(callIndex, callToBeSpli);
 376         TryCatch(r == E_SUCCESS,,"conf. call list corrupted");
 377         //split single call from conference
 378         r = __pTelephonyMgr->SplitFromConference(callToBeSpli.GetCallHandle()->ToLong());
 379         TryCatch(r == E_SUCCESS,,"Split from conf. call failed");
 380         return true;
 381
 382 CATCH:
 383         __pTelEventListener->HandleTelephonyError(ERROR_SPLIT_FROM_CONFERENCE_FAILED);
 384         return false;
 385 }
 386
 387 void
 388 CallPresentationModel::EndCallFromConference(EndConfCallerCmdIds endCallerCmdId, IListT<AppCallInfo>* pConfCallList)
 389 {
 390         int callIndex = -1;
 391         AppCallInfo callToBeEnded;
 392         switch (endCallerCmdId)
 393         {
 394         case IDA_END_CALLER1:
 395                 callIndex = 0;
 396                 break;
 397
 398         case IDA_END_CALLER2:
 399                 callIndex = 1;
 400                 break;
 401
 402         case IDA_END_CALLER3:
 403                 callIndex = 2;
 404                 break;
 405
 406         case IDA_END_CALLER4:
 407                 callIndex = 3;
 408                 break;
 409
 410         case IDA_END_CALLER5:
 411                 callIndex = 4;
 412                 break;
 413
 414         default:
 415         break;
 416         }
 417
 418         result r = pConfCallList->GetAt(callIndex, callToBeEnded);
 419         TryCatch(r == E_SUCCESS,,"conference call list corrupted");
 420         //end single call
 421         r = __pTelephonyMgr->EndFromConference(callToBeEnded.GetCallHandle()->ToLong());
 422         TryCatch(r == E_SUCCESS,,"End single call from conference call failed");
 423
 424         return;
 425
 426 CATCH:
 427         __pTelEventListener->HandleTelephonyError(ERROR_END_CALL_FAILED);
 428         return;
 429 }
 430
 431 bool
 432 CallPresentationModel::IsSplitAllowed(void)
 433 {
 434         return __pTelephonyMgr->IsSplitAllowed();
 435 }
 436
 437 void
 438 CallPresentationModel::AcceptIncomingCall(CallAnsweringOptions answerOptions,int callHandle)
 439 {
 440         result r = E_FAILURE;
 441         if (answerOptions == ANSERWING_OPTION_ACCEPT_CALL)
 442         {
 443                 r = __pTelephonyMgr->AnswerCall(callHandle, true);
 444         }
 445         else
 446         {
 447                 r = __pTelephonyMgr->AcceptCall(answerOptions,callHandle);
 448         }
 449         if (IsFailed(r))
 450         {
 451                 __pTelEventListener->HandleTelephonyError(ERROR_GENERAL);
 452         }
 453 }
 454
 455 IListT<AppCallInfo>*
 456 CallPresentationModel::GetCallListN(void)
 457 {
 458         return __pTelephonyMgr->GetCallListN();
 459 }
 460
 461
 462 bool
 463 CallPresentationModel::RejectCall(int callHandle, bool sendMsg, const String& contactNumber)
 464 {
 465         AppLogDebug("Enter");
 466         if (sendMsg == true && __pAppControlMgr != null)
 467         {
 468                 //launch compose message AppControl
 469                 __isMessageAppControlRunning = __pAppControlMgr->LaunchComposeMessageAppControl(*(const_cast<String*>(&contactNumber)), this);
 470         }
 471         result r = __pTelephonyMgr->AnswerCall(callHandle, false);
 472         if (IsFailed(r))
 473         {
 474                 __pTelEventListener->HandleTelephonyError(ERROR_GENERAL);
 475                 return false;
 476         }
 477
 478
 479         AppLogDebug("Exit");
 480         return true;
 481 }
 482
 483 void CallPresentationModel::OnAppForeground(void)
 484 {
 485         AppLogDebug("Enter %d %d",__isDialAppControlRunning ,__isMessageAppControlRunning);
 486         if (__isDialAppControlRunning == true)
 487         {
 488                 //This comes here, when Dialer AppControl is finished working.
 489                 __isDialAppControlRunning = false;
 490                 __pAppControlMgr->AppControlRequestCompleted();
 491         }
 492         if (__isMessageAppControlRunning == true)
 493         {
 494                 //This comes here, when Message AppControl is finished working.
 495                 __isMessageAppControlRunning = false;
 496                 __pAppControlMgr->AppControlRequestCompleted();
 497                 //Check if this was the last call, then terminate application.
 498                 //And if any calls are active, then those cases are already handled from Other places.
 499                 if( GetCurrentCallCount() == 0 && IsIncomingorDialingCallPresent() == false)
 500                 {
 501                         CallApp* pCallApp = static_cast<CallApp*>(UiApp::GetInstance());
 502                         pCallApp->Terminate();
 503                 }
 504         }
 505 }
 506
 507 void
 508 CallPresentationModel::OnAppControlCompleteResponseReceived(const AppId& appId, const String& operationId, AppCtrlResult appControlResult, const IMap* pExtraData)
 509 {
 510         AppLogDebug("Enter");
 511         if (__isMessageAppControlRunning == true)
 512         {
 513                 //This comes here, when Message AppControl is finished working.
 514                 __isMessageAppControlRunning = false;
 515                 __pAppControlMgr->AppControlRequestCompleted();
 516                 //Check if this was the last call, then terminate application.
 517                 //And if any calls are active, then those cases are already handled from Other places.
 518                 if( GetCurrentCallCount() == 0)
 519                 {
 520                         CallApp* pPhoneApp = static_cast<CallApp*>(UiApp::GetInstance());
 521                         pPhoneApp->Terminate();
 522                 }
 523         }
 524         if(appId.Equals(PROVIDER_ID_PHONE,false) == true &&  operationId.Equals(OPERATION_ID_DIAL,false) == true)
 525         {
 526                 __isDialAppControlRunning = false;
 527
 528                 __pAppControlMgr->AppControlRequestCompleted();
 529                 if(appControlResult == APP_CTRL_RESULT_SUCCEEDED)
 530                 {
 531                         String* pKey = new (std::nothrow) String(PARAM_PHONE_NUMBER);
 532                         if (pExtraData->ContainsKey(*pKey) == true)
 533                         {
 534                                 const String* pPhoneNumber = static_cast<const String*>(pExtraData->GetValue(*pKey));
 535                                 if(pPhoneNumber != null && pPhoneNumber->IsEmpty() == false)
 536                                 {
 537                                         AddCall(*pPhoneNumber);
 538                                 }
 539
 540                         }
 541
 542                 }
 543
 544         }
 545 }
 546
 547 void
 548 CallPresentationModel::AddCall(const String& phoneNumber)
 549 {
 550         ArrayList* pLaunchArgs = null;
 551         SceneManager* pSceneManager = SceneManager::GetInstance();
 552         int currentActiveCallCount = GetCurrentCallCount();
 553         if(currentActiveCallCount <= 1 && IsIncomingorDialingCallPresent() == false)
 554         {
 555                 //make an outgoing call with given number
 556                 String* contactTxt = new (std::nothrow) String(phoneNumber);
 557                 pLaunchArgs =  new (std::nothrow) ArrayList(SingleObjectDeleter);
 558                 pLaunchArgs->Construct();
 559                 pLaunchArgs->Add(contactTxt);
 560                 bool isEmergencyCall = IsEmergencyNumber(*contactTxt, true);
 561
 562                 SceneId nextScene = IDSCN_SCENE_OUTCALL;
 563                 if (isEmergencyCall)
 564                 {
 565                         nextScene = IDSCN_SCENE_OUT_EMERGENCYCALL;
 566                 }
 567                 pSceneManager->GoForward( ForwardSceneTransition( nextScene,
 568                                 SCENE_TRANSITION_ANIMATION_TYPE_NONE, SCENE_HISTORY_OPTION_NO_HISTORY,SCENE_DESTROY_OPTION_KEEP), pLaunchArgs);
 569
 570         }
 571 }
 572
 573 int
 574 CallPresentationModel::GetCurrentCallCount(void)
 575 {
 576         return __pTelephonyMgr->GetCurrentCallCount();
 577 }
 578
 579 bool
 580 CallPresentationModel::CheckSimInitializationIsCompleted()
 581 {
 582         result r = E_FAILURE;
 583         if(__pTelephonyMgr != null)
 584         {
 585                 r = __pTelephonyMgr->CheckIfMOCallIsPossible();
 586         }
 587         return (!IsFailed(r));
 588 }
 589
 590 bool
 591 CallPresentationModel::IsEmergencyNumber(const Tizen::Base::String& phoneNumber, bool isSimInitialized)
 592 {
 593         return __pTelephonyMgr->CheckIfMOCallIsEmergency(phoneNumber, isSimInitialized);
 594 }
 595
 596 void
 597 CallPresentationModel::StartAlert(AppCallInfo& incomingCallInfo)
 598 {
 599         //Adding incoming call sate setting here
 600         if(__pSettingsPresentor != null)
 601         {
 602                 __pSettingsPresentor->SetCallState(CALL_STATE_CALL_VOICE_CONNECTING);
 603         }
 604         __pTelephonyMgr->StartAlert(incomingCallInfo);
 605 }
 606
 607 void
 608 CallPresentationModel::StopAlert(void)
 609 {
 610         __pTelephonyMgr->StopAlert();
 611 }
 612
 613 Contact*
 614 CallPresentationModel::GetContactN(const String& phoneNumber)
 615 {
 616         return __pTelephonyMgr->GetContactN(phoneNumber);
 617 }
 618
 619 AppCallInfo*
 620 CallPresentationModel::FetchIncomingCallDetailsN(const String& callHandle, const String& contactNumber)
 621 {
 622
 623         return __pTelephonyMgr->FetchIncomingCallHandleN(callHandle, contactNumber);
 624 }
 625
 626 bool
 627 CallPresentationModel::CheckIncomingCallToBeRejected(AppCallInfo* pIncomingCallInfo)
 628 {
 629         return __pTelephonyMgr->CheckIncomingCallToBeRejected(pIncomingCallInfo);
 630 }
 631
 632 /////////////////////////////////////////////////////////////////
 633 /////  Event Listener methods from ITelephonyEventListener  /////
 634 /////////////////////////////////////////////////////////////////
 635 void
 636 CallPresentationModel::HandleCallConnected(Tizen::Base::Collection::IListT<AppCallInfo>& pCallList)
 637 {
 638         if (__pTelEventListener != null)
 639         {
 640                 __pTelEventListener->HandleCallConnected(pCallList);
 641         }
 642         if(__pSettingsPresentor != null)
 643         {
 644                 __pSettingsPresentor->SetCallState(CALL_STATE_CALL_VOICE_ACTIVE);
 645         }
 646 }
 647
 648 void
 649 CallPresentationModel::HandleCallDisconnected(bool isLastCall, Tizen::Base::Collection::IListT<AppCallInfo>& pCallList)
 650 {
 651         AppLogDebug("Enter");
 652         if (isLastCall == true)
 653         {
 654                 SetSpeakerStatus(false);
 655                 SetMuteStatus(false);
 656                 if(__pSettingsPresentor != null)
 657                 {
 658                         //Check if there is a incoming call or dialing call present before setting the status
 659                         if(IsIncomingorDialingCallPresent() == false)
 660                         {
 661                         __pSettingsPresentor->SetCallState(CALL_STATE_CALL_OFF);
 662                         }
 663                 }
 664         }
 665         else
 666         {
 667                 if(__pSettingsPresentor != null)
 668                 {
 669                         __pSettingsPresentor->SetCallState(CALL_STATE_CALL_VOICE_ACTIVE);
 670                 }
 671         }
 672         //1) Defer from sending call disconnected event to form, in case Msg AppControl is running,
 673         //to avoid PhoneApp from going to EndCall form, where it shows for 3 sec. and automatically closes.
 674         //2) Do not send call disconnected event to any form, in case an incoming call or dialing call is present.
 675         if (__pTelEventListener != null /*&& __isMessageAppControlRunning == false*/ )
 676         {
 677                 __pTelEventListener->HandleCallDisconnected(isLastCall, pCallList);
 678         }
 679 }
 680
 681 void
 682 CallPresentationModel::HandleConferenceCall(AppCallInfo& pCallInfo)
 683 {
 684         if (__pTelEventListener != null)
 685         {
 686                 __pTelEventListener->HandleConferenceCall(pCallInfo);
 687         }
 688 }
 689
 690 void
 691 CallPresentationModel::HandleIncomingCall(AppCallInfo& pCallInfo)
 692 {
 693         AppLogDebug("Error - This will never come here. Since, now we are getting incoming call event through AppControl!!");
 694 }
 695
 696 void
 697 CallPresentationModel::HandleCallSwapOccured(Tizen::Base::Collection::IListT<AppCallInfo>& pCallList)
 698 {
 699         if (__pTelEventListener != null)
 700         {
 701                 __pTelEventListener->HandleCallSwapOccured(pCallList);
 702         }
 703 }
 704
 705 void
 706 CallPresentationModel::HandleConferenceChange(void)
 707 {
 708         //1) Do not send conf. call changed event to any form, in case an incoming call or dialing call is present.
 709         if (__pTelEventListener != null)
 710         {
 711                 __pTelEventListener->HandleConferenceChange();
 712         }
 713 }
 714
 715 void
 716 CallPresentationModel::HandleTelephonyError(int errorCode)
 717 {
 718         if (__pTelEventListener != null)
 719         {
 720                 __pTelEventListener->HandleTelephonyError(errorCode);
 721         }
 722 }
 723
 724 void
 725 CallPresentationModel::LaunchDialAppControl()
 726 {
 727
 728         if(__isDialAppControlRunning == true)
 729         {
 730                 AppLogDebug("__isDialAppControlRunning == true");
 731                 //Do not allow another app control if already running
 732                 return;
 733         }
 734
 735         //Launch dialer AppControl
 736         if (__pAppControlMgr != null)
 737         {
 738                 __isDialAppControlRunning = __pAppControlMgr->LaunchDialerAppControl(this);
 739         }
 740
 741 }
 742
 743 bool
 744 CallPresentationModel::IsEnableJoinCallButton(void)
 745 {
 746         //Check if conf. call has maximum participants
 747         AppCallInfo* pConfCallInfo = GetConferenceCallInfoN();
 748         if(pConfCallInfo != null && pConfCallInfo->GetCallerListCount() >= IDI_MAX_CONF_CALL_PARTICIPANTS)
 749         {
 750                 return false;
 751         }
 752
 753         //check if either of the caller is same or present in conf call.
 754         IListT<AppCallInfo>* pActiveCallList = GetCallListN();
 755         if ( pActiveCallList != null && pActiveCallList->GetCount() == IDI_MAX_ACTIVE_CALLS)
 756         {
 757                 AppCallInfo firstCall;
 758                 AppCallInfo secondCall;
 759                 pActiveCallList->GetAt(0, firstCall);
 760                 pActiveCallList->GetAt(1, secondCall);
 761
 762                 if (firstCall.IsConferenceCall() == true)
 763                 {
 764                         IListT<AppCallInfo>* pConfMemberList = firstCall.GetCallerList();
 765                         for (int index = 0; index < pConfMemberList->GetCount(); index++)
 766                         {
 767                                 AppCallInfo singleConfMember;
 768                                 pConfMemberList->GetAt(index, singleConfMember);
 769                                 if (secondCall.GetContactNumber().IsEmpty() == false && secondCall.GetContactNumber().Equals(singleConfMember.GetContactNumber()) == true)
 770                                 {
 771                                         return false;
 772                                 }
 773                         }
 774                 }
 775                 else if (secondCall.IsConferenceCall() == true)
 776                 {
 777                         IListT<AppCallInfo>* pConfMemberList = secondCall.GetCallerList();
 778                         for (int index = 0; index < pConfMemberList->GetCount(); index++)
 779                         {
 780                                 AppCallInfo singleConfMember;
 781                                 pConfMemberList->GetAt(index, singleConfMember);
 782                                 if (firstCall.GetContactNumber().IsEmpty() == false && firstCall.GetContactNumber().Equals(singleConfMember.GetContactNumber()) == true)
 783                                 {
 784                                         return false;
 785                                 }
 786                         }
 787                 }
 788                 else
 789                 {
 790                         //Now, we definitely know that both are single active calls.
 791                         if (firstCall.GetContactNumber().IsEmpty() == false && firstCall.GetContactNumber().Equals(secondCall.GetContactNumber()) == true)
 792                         {
 793                                 return false;
 794                         }
 795                 }
 796         }
 797         delete pConfCallInfo;
 798         pConfCallInfo = null;
 799         return true;
 800 }
 801
 802 bool
 803 CallPresentationModel::IsIncomingorDialingCallPresent(void)
 804 {
 805         //returns false, if incoming call or dialed call is present.
 806         return __pTelephonyMgr->IsIncomingorDialingCallPresent();
 807 }
 808
 809 bool
 810 CallPresentationModel::LaunchComposeMessageAppControl(String& contactNumber, IAppControlResponseListener* pListener)
 811 {
 812         if (__pAppControlMgr != null)
 813         {
 814                 return __pAppControlMgr->LaunchComposeMessageAppControl(contactNumber, pListener);
 815         }
 816         return false;
 817 }
 818
 819 bool
 820 CallPresentationModel::LaunchViewContactAppControl(String& contactId, IAppControlResponseListener* pListener)
 821 {
 822         if (__pAppControlMgr != null)
 823         {
 824                 return __pAppControlMgr->LaunchViewContactAppControl(contactId, pListener);
 825         }
 826         return false;
 827 }
 828
 829 bool
 830 CallPresentationModel::LaunchAddContactAppControl(Tizen::Base::String& contactNumber, Tizen::App::IAppControlResponseListener* pListener)
 831 {
 832         if (__pAppControlMgr != null)
 833         {
 834                 return __pAppControlMgr->LaunchAddContactAppControl(contactNumber, pListener);
 835         }
 836         return false;
 837 }
 838
 839 bool
 840 CallPresentationModel::IsAppControlRunning(void)
 841 {
 842         if (__pAppControlMgr != null)
 843         {
 844                 return __pAppControlMgr->IsAppControlRunning();
 845         }
 846         return false;
 847 }
 848
 849 void
 850 CallPresentationModel::AbortAppControlRequest(void)
 851 {
 852         if (__pAppControlMgr != null)
 853         {
 854                 __pAppControlMgr->AbortAppControlRequest();
 855         }
 856 }
 857
 858 void
 859 CallPresentationModel::AppControlRequestCompleted(void)
 860 {
 861         if (__pAppControlMgr != null)
 862         {
 863                 __pAppControlMgr->AppControlRequestCompleted();
 864         }
 865 }
 866
 867 result
 868 CallPresentationModel::GetSimInfo(void)
 869 {
 870         __psimStateManager = new (std::nothrow)SimStateManager();
 871         result r = __psimStateManager->Construct();
 872         if (IsFailed(r))
 873         {
 874                 delete __psimStateManager;
 875                 __psimStateManager = null;
 876                 return E_FAILURE;
 877         }
 878         __psimStateManager->SetSimEventListener(this);
 879
 880         __psimInfo = new (std::nothrow)SimInfo();
 881         r = __psimStateManager->GetSimInfo(*__psimInfo);
 882         if (IsFailed(r))
 883         {
 884                 delete __psimStateManager;
 885                 __psimStateManager = null;
 886                 delete __psimInfo;
 887                 __psimInfo = null;
 888                 return E_FAILURE;
 889         }
 890         return E_SUCCESS;
 891 }
 892
 893 void
 894 CallPresentationModel::OnTelephonyNetworkStatusChanged(const NetworkStatus& networkStatus)
 895 {
 896
 897 }
 898
 899 void
 900 CallPresentationModel::OnTelephonySimStateChanged(Tizen::Telephony::SimState state)
 901 {
 902         if(__psimStateManager != null)
 903         {
 904                 delete __psimStateManager;
 905                 __psimStateManager =null;
 906         }
 907         if(__psimInfo != null)
 908         {
 909                 delete __psimInfo;
 910                 __psimInfo = null;
 911         }
 912
 913         __psimStateManager = new SimStateManager();
 914         result r = __psimStateManager->Construct();
 915         if (IsFailed(r))
 916         {
 917                 delete __psimStateManager;
 918                 __psimStateManager = null;
 919                 return ;
 920         }
 921
 922         __psimInfo = new SimInfo();
 923         r = __psimStateManager->GetSimInfo(*__psimInfo);
 924         if (IsFailed(r))
 925         {
 926                 delete __psimStateManager;
 927                 __psimStateManager = null;
 928                 delete __psimInfo;
 929                 __psimInfo = null;
 930                 return ;
 931         }
 932
 933 }
 934
 935 bool
 936 CallPresentationModel::IsSimAvailable(void)
 937 {
 938         if(__psimInfo != null)
 939         {
 940                 return __psimInfo->IsAvailable();
 941         }
 942         else
 943         {
 944                 return false;
 945         }
 946
 947
 948 }
 949
 950 void
 951 CallPresentationModel::SendMessage(String& strMsg,String& recpientNum)
 952 {
 953         AppLogDebug("Enter");
 954         result r;
 955         if(__pSmsManager == null)
 956         {
 957                 __pSmsManager = new (std::nothrow) SmsManager();
 958                 result r = __pSmsManager->Construct(*this);
 959                 if (IsFailed(r) == true)
 960                 {
 961                         delete __pSmsManager;
 962                         __pSmsManager = null;
 963                         return;
 964                 }
 965
 966         }
 967         RecipientList recipient;
 968         recipient.Add(RECIPIENT_TYPE_TO,recpientNum);
 969         SmsMessage smsMessage;
 970         r = smsMessage.SetText(strMsg);
 971         if (IsFailed(r) == false)
 972         {
 973                 r = __pSmsManager->Send(smsMessage,recipient,true);
 974                 if (IsFailed(r) == false)
 975                 {
 976                         __isMessageSendInProgress = true;
 977                 }
 978
 979         }
 980
 981 }
 982
 983 bool
 984 CallPresentationModel::IsMessageSendingInProgress(void)
 985 {
 986         AppLogDebug("Enter %d",__isMessageSendInProgress);
 987         return __isMessageSendInProgress;
 988 }
 989
 990 void
 991 CallPresentationModel::OnSmsMessageSent(result r)
 992 {
 993         AppLogDebug("Enter");
 994         __isMessageSendInProgress = false;
 995
 996 }