src/CallEndCallForm.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    CallEndCallForm.cpp
  19  * @brief       End Call form implementation
  20  */
  21 #include <FApp.h>
  22 #include <FUi.h>
  23 #include <FMedia.h>
  24 #include "CallApp.h"
  25 #include "CallAppUtility.h"
  26 #include "CallEndCallForm.h"
  27 #include "CallButtonsPanel.h"
  28 #include "CallPresentationModel.h"
  29 #include "CallSceneRegister.h"
  30 #include "CallTypes.h"
  31
  32 using namespace Tizen::App;
  33 using namespace Tizen::Base;
  34 using namespace Tizen::Base::Collection;
  35 using namespace Tizen::Graphics;
  36 using namespace Tizen::Media;
  37 using namespace Tizen::Ui;
  38 using namespace Tizen::Ui::Controls;
  39 using namespace Tizen::Ui::Scenes;
  40 using namespace Tizen::Social;
  41
  42 //constants
  43 const int IDI_APP_END_TIMER = 3000;
  44 const int W_PHOTO_LABEL = 720;
  45 const int H_PHOTO_LABEL = 720;
  46 const int X_PHOTO_LBL = 166;
  47 const int Y_PHOTO_LBL = 232;
  48 const int W_PHOTO_LBL = 388;
  49 const int H_PHOTO_LBL = 388;
  50 static const wchar_t* IDL_END_CALL_FORM = L"IDL_END_CALL_FORM";
  51 static const wchar_t* IDC_NUMBER1_LABEL = L"IDC_NUMBER1_LABEL";
  52 static const wchar_t* IDC_CALLER1_LABEL = L"IDC_CALLER1_LABEL";
  53 static const wchar_t* IDC_KEY_BG_LABEL = L"IDC_KEY_BG_LABEL";
  54 static const wchar_t* IDC_CALLER1_BIGPHOTO_LABEL = L"IDC_CALLER1_BIGPHOTO_LABEL";
  55 static const wchar_t* IDB_END_CALL_DEFAULT_ICON = L"C01-1_call_default_caller ID_720x720.png";
  56
  57
  58 EndCallForm::EndCallForm(void)
  59 : BaseForm(FORMTYPE_ENDCALL)
  60 {
  61         __pCallButtonsPanel = null;
  62         __pContactNumber = null;
  63         __pEndCallEventTimer = null;
  64         __pSmallPhotoLabel = null;
  65         __isMsgAppControlLaunched = false;
  66         __isContactAppControlLaunched = false;
  67         __isContactPresent = false;
  68 }
  69
  70 EndCallForm::~EndCallForm(void)
  71 {
  72         if (__pEndCallEventTimer != null)
  73         {
  74                 __pEndCallEventTimer->Cancel();
  75                 delete __pEndCallEventTimer;
  76                 __pEndCallEventTimer = null;
  77         }
  78         if (__pSmallPhotoLabel != null)
  79         {
  80                 __pSmallPhotoLabel = null;
  81         }
  82 }
  83
  84 void
  85 EndCallForm::Initialize(void)
  86 {
  87         Construct(IDL_END_CALL_FORM);
  88 }
  89
  90 result
  91 EndCallForm::OnInitializing(void)
  92 {
  93         result r = E_SUCCESS;
  94
  95         //initialize keypad and buttons
  96         InitializeCallButtonsPanel();
  97
  98         __pEndCallEventTimer = new (std::nothrow) Tizen::Base::Runtime::Timer();
  99         r = __pEndCallEventTimer->Construct(*this);
 100
 101         __pCallPresentor = CallPresentationModel::GetInstance();
 102         return r;
 103 }
 104
 105 void
 106 EndCallForm::InitializeCallButtonsPanel(void)
 107 {
 108         Label* pKeysBgLbl = static_cast<Label*>(GetControl(IDC_KEY_BG_LABEL, true));
 109         Bitmap* pBgBitmap = AppUtility::GetBitmapFromResourcesN(IDB_BACKGROUND_BITMAP, pKeysBgLbl->GetWidth(), pKeysBgLbl->GetHeight());
 110         if (pBgBitmap != null)
 111         {
 112                 pKeysBgLbl->SetBackgroundBitmap(*pBgBitmap);
 113         }
 114         if (__pCallButtonsPanel == null)
 115         {
 116                 __pCallButtonsPanel = new (std::nothrow) CallButtonsPanel();
 117                 __pCallButtonsPanel->ConstructPanel(this, FORMTYPE_ENDCALL);
 118                 __pCallButtonsPanel->SetBounds(pKeysBgLbl->GetBounds());
 119                 AddControl(*__pCallButtonsPanel);
 120         }
 121
 122         RelativeLayout* pRelativeLayout = dynamic_cast<RelativeLayout*>(GetPortraitLayoutN());
 123         if (pRelativeLayout != null)
 124         {
 125                 pRelativeLayout->SetRelation(*__pCallButtonsPanel, *pKeysBgLbl, RECT_EDGE_RELATION_BOTTOM_TO_BOTTOM);
 126         }
 127         pRelativeLayout = dynamic_cast<RelativeLayout*>(GetLandscapeLayoutN());
 128         if (pRelativeLayout != null)
 129         {
 130                 pRelativeLayout->SetRelation(*__pCallButtonsPanel, *pKeysBgLbl, RECT_EDGE_RELATION_LEFT_TO_LEFT);
 131                 pRelativeLayout->SetRelation(*__pCallButtonsPanel, *pKeysBgLbl, RECT_EDGE_RELATION_RIGHT_TO_RIGHT);
 132         }
 133 }
 134
 135 void
 136 EndCallForm::AddKeyPadActionListener(const String& keyName, CommandIds cmdId)
 137 {
 138         Button* pButton = static_cast<Button*>(GetControl(keyName));
 139         if (pButton != null)
 140         {
 141                 pButton->SetActionId(cmdId);
 142                 pButton->AddActionEventListener(*this);
 143         }
 144 }
 145
 146 result
 147 EndCallForm::OnTerminating(void)
 148 {
 149         result r = E_SUCCESS;
 150
 151         if (__pCallPresentor)
 152         {
 153                 __pCallPresentor = null;
 154         }
 155         return r;
 156 }
 157
 158 void
 159 EndCallForm::OnActionPerformed(const Control& source, int actionId)
 160 {
 161         SceneManager* pSceneManager = SceneManager::GetInstance();
 162         AppAssert(pSceneManager);
 163
 164         switch (actionId)
 165         {
 166         case IDA_VOICE_CALL:
 167         {
 168                 //check if EndCallTimer is running, then cancel it
 169                 if(__pEndCallEventTimer != null)
 170                 {
 171                         __pEndCallEventTimer->Cancel();
 172                 }
 173                 //make an outgoing call with given number
 174                 String* contactTxt = new (std::nothrow) String(*__pContactNumber);
 175                 //switch to dialing outgoing call form
 176                 ArrayList* pContact = new (std::nothrow) ArrayList(SingleObjectDeleter);
 177                 pContact->Construct();
 178                 pContact->Add(contactTxt);
 179
 180                 //Check if dialing a call is possible
 181                 bool isSimInitialized = __pCallPresentor->CheckSimInitializationIsCompleted();
 182                 if (isSimInitialized)
 183                 {
 184                         //Check if dialing an emergency call
 185                         bool isEmergencyCall = __pCallPresentor->IsEmergencyNumber(*contactTxt, true);
 186                         if (isEmergencyCall)
 187                         {
 188                                 pSceneManager->GoForward( ForwardSceneTransition( IDSCN_SCENE_OUT_EMERGENCYCALL), pContact);
 189                         }
 190                         else
 191                         {
 192                                 pSceneManager->GoForward( ForwardSceneTransition(IDSCN_SCENE_OUTCALL), pContact);
 193                         }
 194                 }
 195                 else
 196                 {
 197                         //Show error message Popup
 198                         HandleTelephonyError(ERROR_CODE_SIM_INITIALIZATION_FAILED);
 199                 }
 200         }
 201         break;
 202
 203         case IDA_VIDEO_CALL:
 204                 //Make Video Call
 205                 break;
 206
 207         case IDA_MESSAGE:
 208         {
 209                 if (__isMsgAppControlLaunched == true)
 210                 {
 211                         //AppControl already launched.
 212                         return;
 213                 }
 214                 //launch message AppControl
 215                 __isMsgAppControlLaunched = true;
 216                 result r = E_SUCCESS;
 217                 HashMap extraData;
 218                 extraData.Construct();
 219
 220                 extraData.Add(new (std::nothrow) String(MESSAGE_TYPE), new (std::nothrow) String(MESSAGE_SMS_TYPE));
 221                 extraData.Add(new (std::nothrow) String(MESSAGE_TO), new (std::nothrow) String(*__pContactNumber));
 222
 223                 AppControl* pAc = AppManager::FindAppControlN(PROVIDER_ID_MESSAGE, OPERATION_ID_COMPOSE);
 224                 if (pAc != null)
 225                 {
 226                         r = pAc->Start(null, null, &extraData, this);
 227                         if(r != E_SUCCESS)
 228                         {
 229                                 //AppControl request failed, reset flag.
 230                                 __isMsgAppControlLaunched = false;
 231                         }
 232                         else if (r == E_SUCCESS && __pEndCallEventTimer != null)
 233                         {
 234                                 //cancel EndCallTimer, if AppControl request was successful.
 235                                 __pEndCallEventTimer->Cancel();
 236                         }
 237                         delete pAc;
 238                 }
 239
 240                 extraData.RemoveAll(true);
 241         }
 242         break;
 243
 244         case IDA_ADD_TO_CONTACTS:
 245         {
 246                 if(__isContactAppControlLaunched == true)
 247                 {
 248                         //AppControl already launched.
 249                         AppLogDebug("__isContactAppControlLaunched == true");
 250                         return;
 251                 }
 252                 HandleAddToContacts();
 253         }
 254         break;
 255
 256         default:
 257                 break;
 258         }
 259 }
 260
 261 void
 262 EndCallForm::HandleAddToContacts(void)
 263 {
 264         AppLogDebug("Enter");
 265         //Launch Contact AppControl
 266         __isContactAppControlLaunched = true;
 267         Contact* pContact = __pCallPresentor->GetContactN(*__pContactNumber);
 268         AppControl* pAc = null;
 269         result r = E_SUCCESS;
 270         HashMap extraData;
 271         extraData.Construct();
 272
 273         if (pContact != null)
 274         {
 275                 AppLogDebug("View Contact");
 276                 //View Contact
 277                 String idVal;
 278                 idVal.Append(pContact->GetRecordId());
 279                 extraData.Add(new (std::nothrow) String(CONTACTS_VIEW_TYPE), new (std::nothrow) String(CONTACTS_VIEW_TYPE_CONTACT));
 280                 extraData.Add(new (std::nothrow) String(CONTACTS_VIEW_TYPE_CONTACT), new (std::nothrow) String(CONTACTS_VIEW_TYPE_CONTACT));
 281                 extraData.Add(new (std::nothrow) String(CONTACT_KEY_ITEM_ID), new (std::nothrow) String(idVal));
 282                 extraData.Add(new (std::nothrow) String(CONTACTS_ID_KEY), new (std::nothrow) String(idVal));
 283                 extraData.Add(new (std::nothrow) String(CONTACT_KEY_ITEM_TYPE), new (std::nothrow) String(ITEM_TYPE_PERSON));
 284                  pAc = AppManager::FindAppControlN(PROVIDER_ID_CONTACTS, OPERATION_ID_VIEW);
 285
 286         }
 287         else
 288         {
 289                 AppLogDebug("Add Contact");
 290                 extraData.Add(new (std::nothrow) String(INPUT_TYPE_PHONE), new (std::nothrow) String(*__pContactNumber));
 291                 extraData.Add(new (std::nothrow) String(CONTACT_KEY_ITEM_TYPE), new (std::nothrow) String(ITEM_TYPE_CONTACT));
 292                 pAc = AppManager::FindAppControlN(PROVIDER_ID_CONTACTS, OPERATION_ID_ADD);
 293
 294         }
 295         if (pAc != null)
 296         {
 297                 r = pAc->Start(null, null, &extraData, this);
 298                 if(r != E_SUCCESS)
 299                 {
 300                         //AppControl request failed, reset flag.
 301                         __isContactAppControlLaunched = false;
 302                 }
 303                 else if (r == E_SUCCESS && __pEndCallEventTimer != null)
 304                 {
 305                         //cancel EndCallTimer, if AppControl request was success.
 306                         __pEndCallEventTimer->Cancel();
 307                 }
 308                 delete pAc;
 309         }
 310         else
 311         {
 312                 __isContactAppControlLaunched = false;
 313         }
 314         extraData.RemoveAll(true);
 315         if(pContact != null)
 316         {
 317                 delete pContact;
 318                 pContact = null;
 319         }
 320 }
 321
 322 void
 323 EndCallForm::OnSceneActivatedN(const SceneId& previousSceneId, const SceneId& currentSceneId, IList* pArgs)
 324 {
 325         //set itself as listener
 326         __pCallPresentor->SetTelEventListener(this);
 327         //listen to Foreground events
 328         CallApp* pPhoneApp = static_cast<CallApp*>(CallApp::GetInstance());
 329         pPhoneApp->AddAppStateChangeListener(*this);
 330         __isMsgAppControlLaunched = false;
 331         __isContactAppControlLaunched = false;
 332
 333         switch (__formType)
 334         {
 335         case FORMTYPE_ENDCALL:
 336         {
 337                 //fetch ended call details
 338                 AppCallInfo* pEndCall = static_cast<AppCallInfo*>(pArgs->GetAt(0));
 339
 340                 //contact number
 341                 __pContactNumber = new (std::nothrow) String();
 342                 if(pEndCall->GetContactNumber().IsEmpty() == false)
 343                 {
 344                         __pContactNumber->Append(pEndCall->GetContactNumber());
 345                 }
 346                 else
 347                 {
 348                         __pContactNumber->Append(AppUtility::GetResourceString(IDS_NUMBER_UNKNOWN));
 349                 }
 350
 351                 //Fetch & show contact person details
 352                 ShowPersonDetails(*__pContactNumber, IDC_CALLER1_LABEL, IDC_CALLER1_BIGPHOTO_LABEL,pEndCall);
 353                 //If call is hidden means contact number is empty,
 354                 //or if call is from known number(i.e present in contacts db), Then do NOT show "Add to Contact" button.
 355                 if (pEndCall->GetContactInfo() != null || pEndCall->GetContactNumber().IsEmpty() == true)
 356                 {
 357                         Contact* pContact = __pCallPresentor->GetContactN(pEndCall->GetContactNumber());
 358                         //before setting check if the contact is deleted
 359                         if(pContact != null)
 360                         {
 361                                 SetContactButtonState(false);
 362                                 delete pContact;
 363                                 pContact = null;
 364                         }
 365                         else
 366                         {
 367                                 SetContactButtonState(true);
 368                         }
 369                 }
 370                 else
 371                 {
 372                         SetContactButtonState(true);
 373                 }
 374
 375                 //Check if call is Emergency call or Hidden call,
 376                 //then disable all button in Call button panel.
 377                 if (pEndCall->IsEmergency() == true || pEndCall->GetContactNumber().IsEmpty() == true)
 378                 {
 379                         __pCallButtonsPanel->SetEndCallPanelState(false);
 380                 }
 381                 else
 382                 {
 383                         __pCallButtonsPanel->SetEndCallPanelState(true);
 384                 }
 385         }
 386         break;
 387
 388         default:
 389                 break;
 390         }
 391
 392         if (__pEndCallEventTimer)
 393         {
 394                 __pEndCallEventTimer->Start(IDI_APP_END_TIMER);
 395         }
 396
 397         if (pArgs)
 398         {
 399                 pArgs->RemoveAll();
 400                 delete pArgs;
 401                 pArgs = null;
 402         }
 403         AddOrientationEventListener(*this);
 404 }
 405
 406 void
 407 EndCallForm::OnSceneDeactivated(const SceneId& currentSceneId, const SceneId& nextSceneId)
 408 {
 409         if (__pEndCallEventTimer != null)
 410         {
 411                 __pEndCallEventTimer->Cancel();
 412         }
 413         if (__pContactNumber)
 414         {
 415                 delete __pContactNumber;
 416                 __pContactNumber = null;
 417         }
 418         if (__pSmallPhotoLabel != null)
 419         {
 420                 __pSmallPhotoLabel->SetShowState(false);
 421         }
 422         //remove itself as listener
 423         CallApp* pPhoneApp = static_cast<CallApp*>(CallApp::GetInstance());
 424         pPhoneApp->RemoveAppStateChangeListener(*this);
 425         RemoveOrientationEventListener(*this);
 426 }
 427
 428 result
 429 EndCallForm::OnDraw(void)
 430 {
 431         return E_SUCCESS;
 432 }
 433
 434 void
 435 EndCallForm::SetContactButtonState(bool showState)
 436 {
 437         __pCallButtonsPanel->SetViewContactButtonStatus(showState);
 438         __isContactPresent = !showState;
 439 }
 440
 441 bool
 442 EndCallForm::IsContactPresent(void)
 443 {
 444         return __isContactPresent;
 445 }
 446
 447
 448 void
 449 EndCallForm::ShowPhoneNumber(const String& phoneNumber, const String& lblName)
 450 {
 451         String formattedNumber = phoneNumber;
 452         Label* pContactLbl = static_cast<Label*>(GetControl(lblName));
 453         pContactLbl->SetText(formattedNumber);
 454 }
 455
 456 void
 457 EndCallForm::ShowPersonDetails(const String& phoneNumber, const String& nameLblName, const String& photoLblName, AppCallInfo* pCallInfo)
 458 {
 459         //show phone number
 460         ShowPhoneNumber(phoneNumber, IDC_NUMBER1_LABEL);
 461
 462         Label* pNameLbl = static_cast<Label*>(GetControl(nameLblName));
 463         Label* pPhotoLbl = static_cast<Label*>(GetControl(photoLblName));
 464
 465         //fetch contact details based on phone number
 466         String* pDisplayName = pCallInfo->FetchCallerNameN();
 467         Bitmap* pPhotoBitmap = pCallInfo->FetchCallerPhotoN();
 468
 469         //passing an empty string to SetText fails in label,
 470         //if previously valid text has been set
 471         if (pDisplayName != null && pDisplayName->IsEmpty() == true && pNameLbl->GetText().IsEmpty() == false)
 472         {
 473                 pDisplayName->Append(L" ");
 474         }
 475
 476         // show display name on name Label
 477         if (pDisplayName != null)
 478         {
 479                 pNameLbl->SetText(*pDisplayName);
 480         }
 481
 482         // If record not found or no photo id present for user,
 483         //fetch default bitmap.
 484         if (pPhotoBitmap != null)
 485         {
 486                 if(pPhotoBitmap->GetHeight() <= H_SMALL_PHOTO
 487                                 && pPhotoBitmap->GetWidth() <= W_SMALL_PHOTO)
 488                 {
 489                         ShowThumbnailImage(pPhotoBitmap,photoLblName);
 490                 }
 491                 else
 492                 {
 493                         Canvas* pCanvas = new (std::nothrow) Canvas;
 494                         Rectangle canvasRect(Rectangle(0, 0, pPhotoLbl->GetBounds().width, pPhotoLbl->GetBounds().height));
 495                         pCanvas->Construct(canvasRect);
 496                         //draw the contact bitmap
 497                         pCanvas->DrawBitmap(canvasRect,*pPhotoBitmap);
 498                         Bitmap* pNewPhotoId = new Bitmap();
 499                         pNewPhotoId->Construct(*pCanvas, pCanvas->GetBounds());
 500                         delete pCanvas;
 501
 502                         pPhotoLbl->SetBackgroundBitmap(*pNewPhotoId);
 503                         pPhotoLbl->Invalidate(true);
 504                         delete pNewPhotoId;
 505                 }
 506         }
 507         else
 508         {
 509                 //Set Default Photo
 510                 Bitmap* pDefaultPhoto = AppUtility::GetBitmapFromResourcesN(IDB_END_CALL_DEFAULT_ICON,W_PHOTO_LABEL,H_PHOTO_LABEL);
 511                 if (pDefaultPhoto != null)
 512                 {
 513                         pPhotoLbl->SetBackgroundBitmap(*pDefaultPhoto);
 514                         pPhotoLbl->Invalidate(true);
 515                         delete pDefaultPhoto;
 516                 }
 517         }
 518         RequestRedraw(true);
 519         //free resources
 520         if (pDisplayName)
 521         {
 522                 delete pDisplayName;
 523                 pDisplayName = null;
 524         }
 525         if (pPhotoBitmap)
 526         {
 527                 delete pPhotoBitmap;
 528                 pPhotoBitmap = null;
 529         }
 530 }
 531
 532 void
 533 EndCallForm::ShowThumbnailImage(const Bitmap* pPhotoId,const String& photoLabel)
 534 {
 535         Label* pPhotoLbl = static_cast<Label*>(GetControl(photoLabel));
 536
 537         if (pPhotoLbl != null && pPhotoId != null)
 538         {
 539                 Canvas* pCanvas = new (std::nothrow) Canvas;
 540                 Bitmap* pBackground = AppUtility::GetBitmapFromResourcesN(IDB_CALL_THUMBNAIL_BACKGROUND,W_CALL_THUMBNAIL,H_CALL_THUMBNAIL);
 541                 Bitmap* pShadow = AppUtility::GetBitmapFromResourcesN(IDB_CALL_THUMBNAIL_SHADOW,W_CALL_THUMBNAIL_SHADOW,H_CALL_THUMBNAIL_SHADOW);
 542                 Rectangle canvasRect(Rectangle(0, 0, pPhotoLbl->GetBounds().width, pPhotoLbl->GetBounds().height));
 543                 pCanvas->Construct(canvasRect);
 544                 //draw the back ground
 545                 pCanvas->DrawBitmap(canvasRect,*pBackground);
 546                 //draw shadow (to be enabled after correct shadow image is provided )
 547                 //pCanvas->DrawBitmap(Rectangle((pPhotoLbl->GetBounds().width/2)-(W_CALL_THUMBNAIL_SHADOW/2),
 548                         //      (pPhotoLbl->GetBounds().height/2)-(H_CALL_THUMBNAIL_SHADOW/2),W_CALL_THUMBNAIL_SHADOW,H_CALL_THUMBNAIL_SHADOW),*pShadow);
 549                 //draw the contact bitmap
 550                 pCanvas->DrawBitmap(Rectangle((pPhotoLbl->GetBounds().width/2)-(W_SMALL_PHOTO/2),
 551                                 (pPhotoLbl->GetBounds().height/2)-(H_SMALL_PHOTO/2),W_SMALL_PHOTO,H_SMALL_PHOTO),*pPhotoId);
 552                 Bitmap* pNewPhotoId = new Bitmap();
 553                 pNewPhotoId->Construct(*pCanvas, pCanvas->GetBounds());
 554                 delete pCanvas;
 555
 556                 pPhotoLbl->SetBackgroundBitmap(*pNewPhotoId);
 557                 pPhotoLbl->Invalidate(true);
 558                 delete pNewPhotoId;
 559                 delete pBackground;
 560                 delete pShadow;
 561         }
 562
 563 }
 564
 565 void
 566 EndCallForm::ShowCallersPhotoThumbnail(const Bitmap& pPhotoId)
 567 {
 568         if (__pSmallPhotoLabel != null)
 569         {
 570                 RemoveControl(*__pSmallPhotoLabel);
 571                 __pSmallPhotoLabel = null;
 572         }
 573         //Draw Small Photo and show on small photo label
 574         __pSmallPhotoLabel  = new (std::nothrow) Label();//static_cast<Label*>(GetControl(IDC_SMALL_PHOTO_LABEL));
 575         __pSmallPhotoLabel->Construct(Rectangle(X_PHOTO_LBL, Y_PHOTO_LBL, W_PHOTO_LBL, H_PHOTO_LBL), L"");
 576         __pSmallPhotoLabel->SetBackgroundColor(Color(0,0,0));
 577         __pSmallPhotoLabel->SetBackgroundBitmap(pPhotoId);
 578         // Add a Label to the Form
 579         AddControl(*__pSmallPhotoLabel);
 580         __pSmallPhotoLabel->Invalidate(true);
 581 }
 582
 583 void
 584 EndCallForm::OnTimerExpired(Tizen::Base::Runtime::Timer& timer)
 585 {
 586         //goto initial scene or close application, since this was last active call.
 587         HandleLastCallCompletion();
 588 }
 589
 590 void
 591 EndCallForm::OnAppControlCompleteResponseReceived(const AppId& appId, const String& operationId, AppCtrlResult appControlResult, const IMap* pExtraData)
 592 {
 593         AppLogDebug("Enter");
 594         if (__isMsgAppControlLaunched == true)
 595         {
 596                 //Message AppControl request completed.
 597                 __isMsgAppControlLaunched = false;
 598         }
 599         //AppControl completed, goto initial scene if present
 600         //else exit.
 601         HandleLastCallCompletion();
 602 }
 603
 604 void
 605 EndCallForm::HandleLastCallCompletion(void)
 606 {
 607
 608         CallApp* pPhoneApp = (static_cast<CallApp*>(UiApp::GetInstance()));
 609         pPhoneApp->Terminate();
 610
 611 }
 612
 613 void
 614 EndCallForm::OnForeground(void)
 615 {
 616         AppLogDebug("Enter");
 617         //If Contact app control was launched
 618         //as we do not know if it success or failed.
 619         if(__isContactAppControlLaunched == true)
 620         {
 621                 //CallApp* pPhoneApp = (static_cast<CallApp*>(UiApp::GetInstance()));
 622                 //pPhoneApp->Terminate();
 623                 if(__pEndCallEventTimer != null)
 624                 {
 625                         __pEndCallEventTimer->Start(2000);
 626                 }
 627         }
 628         __isContactAppControlLaunched = false;
 629
 630         if (__isMsgAppControlLaunched == true)
 631         {
 632                 //Message AppControl request completed.
 633                 //CallApp* pPhoneApp = (static_cast<CallApp*>(UiApp::GetInstance()));
 634                 //pPhoneApp->Terminate();
 635                 if(__pEndCallEventTimer != null)
 636                 {
 637                         __pEndCallEventTimer->Start(2000);
 638                 }
 639                 __isMsgAppControlLaunched = false;
 640         }
 641         AppLogDebug("Exit");
 642 }
 643
 644 void
 645 EndCallForm::OnBackground(void)
 646 {
 647         AppLogDebug("Enter");
 648 }
 649
 650 void
 651 EndCallForm::OnOrientationChanged(const Tizen::Ui::Control& source, Tizen::Ui::OrientationStatus orientationStatus)
 652 {
 653         AppLogDebug("Enter");
 654         if (__pCallButtonsPanel != null)
 655         {
 656                 //update position of call buttons panel
 657                 Label* pKeysBgLbl = static_cast<Label*>(GetControl(IDC_KEY_BG_LABEL, true));
 658                 __pCallButtonsPanel->SetBounds(pKeysBgLbl->GetBounds());
 659                 //bring button on top
 660                 __pCallButtonsPanel->SetButtonPosition();
 661                 RelativeLayout* pRelativeLayout = dynamic_cast<RelativeLayout*>(GetPortraitLayoutN());
 662                 if (pRelativeLayout != null)
 663                 {
 664                         //pRelativeLayout->SetRelation(*__pCallButtonsPanel, *pKeysBgLbl, RECT_EDGE_RELATION_TOP_TO_TOP);
 665                 }
 666                 pRelativeLayout = dynamic_cast<RelativeLayout*>(GetLandscapeLayoutN());
 667                 if (pRelativeLayout != null)
 668                 {
 669                         pRelativeLayout->SetRelation(*__pCallButtonsPanel, *pKeysBgLbl, RECT_EDGE_RELATION_LEFT_TO_LEFT);
 670                         pRelativeLayout->SetRelation(*__pCallButtonsPanel, *this, RECT_EDGE_RELATION_RIGHT_TO_RIGHT);
 671                 }
 672         }
 673 }