src/PhnConfCallerListForm.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    PhnConfCallerListForm.cpp
  19  * @brief       Conference caller list form
  20  */
  21 #include <FSystem.h>
  22 #include "PhnConfCallerListForm.h"
  23 #include "PhnAppUtility.h"
  24 #include "PhnCallPresentationModel.h"
  25 #include "PhnSceneRegister.h"
  26
  27 using namespace Tizen::App;
  28 using namespace Tizen::Base;
  29 using namespace Tizen::Base::Collection;
  30 using namespace Tizen::Base::Runtime;
  31 using namespace Tizen::Base::Utility;
  32 using namespace Tizen::Graphics;
  33 using namespace Tizen::System;
  34 using namespace Tizen::Ui;
  35 using namespace Tizen::Ui::Controls;
  36 using namespace Tizen::Ui::Scenes;
  37
  38 //Constants
  39 const int W_HOLD_BITMAP = 78;
  40 const int H_HOLD_BITMAP = 78;
  41 const int W_BACK_BITMAP = 56;
  42 const int H_BACK_BITMAP = 56;
  43 const int X_BACK_BITMAP = 8;
  44 const int Y_BACK_BITMAP = 8;
  45 const int W_SPLIT_BITMAP = 66;
  46 const int H_SPLIT_BITMAP = 68;
  47 const int W_END_BITMAP = 80;
  48 const int H_END_BITMAP = 74;
  49 const int IDI_MAX_SECONDS = 60;
  50 const int IDI_MAX_MINS = 60;
  51
  52 static const wchar_t* IDL_CONFCALL_LIST_FORM = L"IDL_CONFCALL_LIST_FORM";
  53 static const wchar_t* IDC_CALL_TIME_LABEL = L"IDC_CALL_TIME_LABEL";
  54 static const wchar_t* IDB_BACK_BUTTON_ICON = L"C01-1_btn_back.png";
  55 static const wchar_t* IDB_SPLIT_NORMAL_BUTTON_ICON = L"C01-1_conference_split.png";
  56 static const wchar_t* IDB_SPLIT_PRESS_BUTTON_ICON = L"C01-1_conference_split_press.png";
  57 static const wchar_t* IDB_END_NORMAL_BUTTON_ICON = L"C01-1_conference_end.png";
  58 static const wchar_t* IDB_END_PRESS_BUTTON_ICON = L"C01-1_conference_end_press.png";
  59 static const wchar_t* IDC_END_CONFCALL_BUTTON = L"IDC_END_CONFCALL_BUTTON";
  60 static const wchar_t* IDC_HOLD_CONFCALL_BUTTON = L"IDC_HOLD_CONFCALL_BUTTON";
  61 static const wchar_t* IDC_BACK_BUTTON = L"IDC_BACK_BUTTON";
  62 static const wchar_t* IDC_CALLER1_PANEL = L"IDC_CALLER1_PANEL";
  63 static const wchar_t* IDC__LINE_LABEL1 = L"IDC__LINE_LABEL1";
  64 static const wchar_t* IDC_CALLER2_PANEL = L"IDC_CALLER2_PANEL";
  65 static const wchar_t* IDC__LINE_LABEL2 = L"IDC__LINE_LABEL2";
  66 static const wchar_t* IDC_CALLER3_PANEL = L"IDC_CALLER3_PANEL";
  67 static const wchar_t* IDC__LINE_LABEL3 = L"IDC__LINE_LABEL3";
  68 static const wchar_t* IDC_CALLER4_PANEL = L"IDC_CALLER4_PANEL";
  69 static const wchar_t* IDC__LINE_LABEL4 = L"IDC__LINE_LABEL4";
  70 static const wchar_t* IDC_CALLER5_PANEL = L"IDC_CALLER5_PANEL";
  71 static const wchar_t* IDC__LINE_LABEL5 = L"IDC__LINE_LABEL5";
  72 static const wchar_t* IDC_END_CALLER1 = L"IDC_END_CALLER1";
  73 static const wchar_t* IDC_SPLIT_CALLER1 = L"IDC_SPLIT_CALLER1";
  74 static const wchar_t* IDC_CALLER1_LABEL = L"IDC_CALLER1_LABEL";
  75 static const wchar_t* IDC_END_CALLER2 = L"IDC_END_CALLER2";
  76 static const wchar_t* IDC_SPLIT_CALLER2 = L"IDC_SPLIT_CALLER2";
  77 static const wchar_t* IDC_CALLER2_LABEL = L"IDC_CALLER2_LABEL";
  78 static const wchar_t* IDC_END_CALLER3 = L"IDC_END_CALLER3";
  79 static const wchar_t* IDC_SPLIT_CALLER3 = L"IDC_SPLIT_CALLER3";
  80 static const wchar_t* IDC_CALLER3_LABEL = L"IDC_CALLER3_LABEL";
  81 static const wchar_t* IDC_END_CALLER4 = L"IDC_END_CALLER4";
  82 static const wchar_t* IDC_SPLIT_CALLER4 = L"IDC_SPLIT_CALLER4";
  83 static const wchar_t* IDC_CALLER4_LABEL = L"IDC_CALLER4_LABEL";
  84 static const wchar_t* IDC_END_CALLER5 = L"IDC_END_CALLER5";
  85 static const wchar_t* IDC_SPLIT_CALLER5 = L"IDC_SPLIT_CALLER5";
  86 static const wchar_t* IDC_CALLER5_LABEL = L"IDC_CALLER5_LABEL";
  87
  88 ConfCallerListForm::ConfCallerListForm(void)
  89 : BaseForm(FORMTYPE_CONFCALLLIST)
  90 {
  91         __pConfCallInfo = null;
  92         __pConfCallTimer = null;
  93 }
  94
  95 ConfCallerListForm::~ConfCallerListForm(void)
  96 {
  97         if (__pConfCallTimer != null)
  98         {
  99                 __pConfCallTimer->Cancel();
 100                 delete __pConfCallTimer;
 101         }
 102 }
 103
 104 void
 105 ConfCallerListForm::Initialize(void)
 106 {
 107         Construct(IDL_CONFCALL_LIST_FORM);
 108 }
 109
 110 result
 111 ConfCallerListForm::OnInitializing(void)
 112 {
 113         result r = E_SUCCESS;
 114         Bitmap* pRejectMessageBitmap = null;
 115         AppResource* pAppResource = null;
 116         Button* pButtonKeypad = null;
 117
 118         //Add action listener to buttons
 119         AddActionListener(IDC_END_CONFCALL_BUTTON, IDA_END_CONF_CALL);
 120         AddActionListener(IDC_HOLD_CONFCALL_BUTTON, IDA_HOLD_CONF_CALL);
 121
 122         pAppResource = AppResource::GetInstance();
 123         pButtonKeypad = static_cast<Button*>(GetControl(IDC_BACK_BUTTON));
 124
 125         if (pButtonKeypad != null)
 126         {
 127                 pButtonKeypad->SetActionId(IDA_BACK_EVENT);
 128                 pButtonKeypad->AddActionEventListener(*this);
 129                 pRejectMessageBitmap = pAppResource->GetBitmapN(IDB_BACK_BUTTON_ICON);
 130                 pRejectMessageBitmap->Scale(Dimension(W_BACK_BITMAP, H_BACK_BITMAP));
 131                 pButtonKeypad->SetNormalBitmap(Point(X_BACK_BITMAP, X_BACK_BITMAP), *pRejectMessageBitmap);
 132                 delete pRejectMessageBitmap;
 133                 pRejectMessageBitmap = null;
 134         }
 135
 136         __pCallPresentor = CallPresentationModel::GetInstance();
 137         return r;
 138 }
 139
 140 void
 141 ConfCallerListForm::AddActionListener(const String& keyName, CommandIds cmdId)
 142 {
 143         Button* pButtonKeypad = static_cast<Button*>(GetControl(keyName));
 144         if (pButtonKeypad != null)
 145         {
 146                 pButtonKeypad->SetActionId(cmdId);
 147                 pButtonKeypad->AddActionEventListener(*this);
 148         }
 149 }
 150
 151 result
 152 ConfCallerListForm::OnTerminating(void)
 153 {
 154         result r = E_SUCCESS;
 155
 156         if (__pCallPresentor != null)
 157         {
 158                 __pCallPresentor = null;
 159         }
 160
 161         if (__pConfCallInfo != null)
 162         {
 163                 delete __pConfCallInfo;
 164                 __pConfCallInfo = null;
 165         }
 166
 167         RemoveAllControls();
 168         return r;
 169 }
 170
 171 void
 172 ConfCallerListForm::OnActionPerformed(const Control& source, int actionId)
 173 {
 174         SceneManager* pSceneManager = SceneManager::GetInstance();
 175         AppAssert(pSceneManager);
 176
 177         switch (actionId)
 178         {
 179         case IDA_END_CONF_CALL:
 180         {
 181                 bool success = __pCallPresentor->EndConferenceCall();
 182                 if (success == true)
 183                 {
 184                         delete __pConfCallInfo;
 185                         __pConfCallInfo = null;
 186                 }
 187         }
 188         break;
 189
 190         case IDA_HOLD_CONF_CALL:
 191         {
 192                 // User has pressed end conference call and we are waiting for TAPI response
 193                 if(__pConfCallInfo == null)
 194                 {
 195                         return;
 196                 }
 197                 bool success = true;
 198                 bool isCallOnHold = __pConfCallInfo->IsOnHold();
 199                 if (isCallOnHold == false)
 200                 {
 201                         success = __pCallPresentor->HoldConferenceCall();
 202                 }
 203                 else
 204                 {
 205                         success = __pCallPresentor->ActivateConferenceCall();
 206                 }
 207
 208                 //Check if request to Hold / UnHold call is successful.
 209                 if(success == true)
 210                 {
 211                         //If success, then invert the Hold status in conference call
 212                         isCallOnHold = !(isCallOnHold);
 213                         __pConfCallInfo->SetOnHold(isCallOnHold);
 214                         //update panels and Hold button status
 215                         ActivatePanels();
 216                         SetHoldButtonStatus(isCallOnHold);
 217                 }
 218         }
 219         break;
 220
 221         case IDA_BACK_EVENT:
 222         {
 223                 ArrayListT<CallInfo>* pCallList  = static_cast<ArrayListT<CallInfo>*>(__pCallPresentor->GetCallListN());
 224                 int noOfCalls = pCallList->GetCount();
 225
 226                 //Ownership - To be deleted in 'OnSceneActivatedN' of next form
 227                 ArrayList* pCallInfoList = new (std::nothrow) ArrayList(SingleObjectDeleter);
 228                 pCallInfoList->Construct(noOfCalls);
 229
 230                 for (int index = 0; index < noOfCalls; index++)
 231                 {
 232                         //fetch call info and add to list
 233                         CallInfo callInfo;
 234                         result r = pCallList->GetAt(index, callInfo);
 235                         if (r == E_SUCCESS)
 236                         {
 237                                 //copy call information to new instance
 238                                 CallInfo* pCaller = new (std::nothrow) CallInfo();
 239                                 *pCaller = callInfo;
 240                                 pCallInfoList->Add(pCaller);
 241                         }
 242                 }
 243
 244                 if (noOfCalls == 1)
 245                 {
 246                         //single active call - goto active call form
 247                         pSceneManager->GoForward(ForwardSceneTransition(IDSCN_SCENE_CONFCALL), pCallInfoList);
 248                 }
 249                 else
 250                 {
 251                         //goto multiple active call form
 252                         pSceneManager->GoForward(ForwardSceneTransition(IDSCN_SCENE_MULTIPLEACTIVECALL), pCallInfoList);
 253                 }
 254                 pCallList->RemoveAll();
 255                 delete pCallList;
 256         }
 257         break;
 258
 259         case IDA_SPLIT_CALLER1:
 260         case IDA_SPLIT_CALLER2:
 261         case IDA_SPLIT_CALLER3:
 262         case IDA_SPLIT_CALLER4:
 263         case IDA_SPLIT_CALLER5:
 264         {
 265                 // User has pressed end conference call and we are waiting for TAPI response
 266                 if(__pConfCallInfo == null)
 267                 {
 268                         break;
 269                 }
 270                 __pCallPresentor->SplitFromConference(SplitConfCallerCmdIds(actionId),__pConfCallInfo->GetCallerList());
 271         }
 272         break;
 273
 274         case IDA_END_CALLER1:
 275         case IDA_END_CALLER2:
 276         case IDA_END_CALLER3:
 277         case IDA_END_CALLER4:
 278         case IDA_END_CALLER5:
 279         {
 280                 // User has pressed end conference call and we are waiting for TAPI response
 281                 if(__pConfCallInfo == null)
 282                 {
 283                         break;
 284                 }
 285                 __pCallPresentor->EndCallFromConference(EndConfCallerCmdIds(actionId),__pConfCallInfo->GetCallerList());
 286         }
 287         break;
 288
 289         default:
 290                 break;
 291         }
 292 }
 293
 294 void
 295 ConfCallerListForm::OnSceneActivatedN(const SceneId& previousSceneId, const SceneId& currentSceneId, IList* pArgs)
 296 {
 297         //set itself as listener
 298         __pCallPresentor->SetTelEventListener(this);
 299
 300         DisableAllControls();
 301         if (__pConfCallInfo != null)
 302         {
 303                 delete __pConfCallInfo;
 304                 __pConfCallInfo = null;
 305         }
 306         //show 1st caller's info.
 307         //Fetch Conference call info from telephony manager
 308         __pConfCallInfo = __pCallPresentor->GetConferenceCallInfoN();
 309
 310         //show active call timer
 311         ShowTimerInfo(IDC_CALL_TIME_LABEL, __pConfCallInfo->GetCallConnectTime());
 312
 313         //Set the correct bitmap to the "hold" button based on the current state of the call
 314         SetHoldButtonStatus(__pConfCallInfo->IsOnHold());
 315         //disable Hold Button, if 2 active calls are present,Else enable it.
 316         Button* pButtonHold = static_cast<Button*>(GetControl(IDC_HOLD_CONFCALL_BUTTON));
 317         if(pButtonHold != null)
 318         {
 319                 if (__pCallPresentor->GetCurrentCallCount() == IDI_MAX_ACTIVE_CALLS)
 320                 {
 321                         pButtonHold->SetShowState(false);
 322                 }
 323                 else
 324                 {
 325                         pButtonHold->SetShowState(true);
 326                 }
 327                 pButtonHold->Invalidate(true);
 328         }
 329
 330         ActivatePanels();
 331 }
 332
 333 void
 334 ConfCallerListForm::OnSceneDeactivated(const SceneId& currentSceneId, const SceneId& nextSceneId)
 335 {
 336         if (__pConfCallInfo != null)
 337         {
 338                 delete __pConfCallInfo;
 339                 __pConfCallInfo = null;
 340         }
 341         if (__pConfCallTimer != null)
 342         {
 343                 __pConfCallTimer->Cancel();
 344                 delete __pConfCallTimer;
 345                 __pConfCallTimer = null;
 346         }
 347 }
 348
 349 result
 350 ConfCallerListForm::OnDraw(void)
 351 {
 352         return E_SUCCESS;
 353 }
 354
 355 void
 356 ConfCallerListForm::SetHoldButtonStatus(bool isCallOnHold)
 357 {
 358         Button* pButtonHold = static_cast<Button*>(GetControl(IDC_HOLD_CONFCALL_BUTTON));
 359         if(pButtonHold != null)
 360         {
 361                 Bitmap* pNormalBitmapToBeDrawn = null;
 362                 Bitmap* pPressBitmapToBeDrawn = null;
 363
 364                 if (isCallOnHold == true)
 365                 {
 366                         pNormalBitmapToBeDrawn = AppUtility::GetBitmapFromResourcesN(IDB_UNHOLD_NORMAL_BUTTON_ICON,
 367                                         W_HOLD_BITMAP, W_HOLD_BITMAP);
 368                         pPressBitmapToBeDrawn = AppUtility::GetBitmapFromResourcesN(IDB_UNHOLD_PRESS_BUTTON_ICON,
 369                                         W_HOLD_BITMAP, W_HOLD_BITMAP);
 370                 }
 371                 else
 372                 {
 373                         pNormalBitmapToBeDrawn = AppUtility::GetBitmapFromResourcesN(IDB_HOLD_NORMAL_BUTTON_ICON,
 374                                         W_HOLD_BITMAP, W_HOLD_BITMAP);
 375                         pPressBitmapToBeDrawn = AppUtility::GetBitmapFromResourcesN(IDB_HOLD_PRESS_BUTTON_ICON,
 376                                         W_HOLD_BITMAP, W_HOLD_BITMAP);
 377                 }
 378
 379                 if (pNormalBitmapToBeDrawn)
 380                 {
 381                         pButtonHold->SetNormalBitmap(Point(0, 0), *pNormalBitmapToBeDrawn);
 382                 }
 383                 if (pPressBitmapToBeDrawn)
 384                 {
 385                         pButtonHold->SetPressedBitmap(Point(0, 0), *pPressBitmapToBeDrawn);
 386                 }
 387
 388                 pButtonHold->Invalidate(true);
 389                 delete pNormalBitmapToBeDrawn;
 390                 pNormalBitmapToBeDrawn = null;
 391                 delete pPressBitmapToBeDrawn;
 392                 pPressBitmapToBeDrawn = null;
 393         }
 394 }
 395
 396 void
 397 ConfCallerListForm::HandleCallChange(void)
 398 {
 399         CallInfo* pCallInfo = __pCallPresentor->GetConferenceCallInfoN();
 400         if (pCallInfo == null)
 401         {
 402                 return;
 403         }
 404         if (__pConfCallInfo != null)
 405         {
 406                 delete __pConfCallInfo;
 407                 __pConfCallInfo = null;
 408         }
 409         __pConfCallInfo = new (std::nothrow) CallInfo();
 410         *__pConfCallInfo = *pCallInfo;
 411         //Disable all key panels and redraw with new caller list
 412         DisableAllControls();
 413         ActivatePanels();
 414 }
 415
 416 void
 417 ConfCallerListForm::DisableAllControls(void)
 418 {
 419         Panel* pKeysPanel = static_cast<Panel*>(GetControl(IDC_CALLER1_PANEL));
 420         if (pKeysPanel != null)
 421         {
 422                 pKeysPanel->SetShowState(false);
 423                 Label* pLineLabel1 = static_cast<Label*>(GetControl(IDC__LINE_LABEL1));
 424                 pLineLabel1->SetShowState(false);
 425                 pKeysPanel = null;
 426         }
 427         pKeysPanel = static_cast<Panel*>(GetControl(IDC_CALLER2_PANEL));
 428         if (pKeysPanel != null)
 429         {
 430                 pKeysPanel->SetShowState(false);
 431                 Label* pLineLabel1 = static_cast<Label*>(GetControl(IDC__LINE_LABEL2));
 432                 pLineLabel1->SetShowState(false);
 433                 pKeysPanel = null;
 434         }
 435         pKeysPanel = static_cast<Panel*>(GetControl(IDC_CALLER3_PANEL));
 436         if (pKeysPanel != null)
 437         {
 438                 pKeysPanel->SetShowState(false);
 439                 Label* pLineLabel1 = static_cast<Label*>(GetControl(IDC__LINE_LABEL3));
 440                 pLineLabel1->SetShowState(false);
 441                 pKeysPanel = null;
 442         }
 443         pKeysPanel = static_cast<Panel*>(GetControl(IDC_CALLER4_PANEL));
 444         if (pKeysPanel != null)
 445         {
 446                 pKeysPanel->SetShowState(false);
 447                 Label* pLineLabel1 = static_cast<Label*>(GetControl(IDC__LINE_LABEL4));
 448                 pLineLabel1->SetShowState(false);
 449                 pKeysPanel = null;
 450         }
 451         pKeysPanel = static_cast<Panel*>(GetControl(IDC_CALLER5_PANEL));
 452         if (pKeysPanel != null)
 453         {
 454                 pKeysPanel->SetShowState(false);
 455                 Label* pLineLabel1 = static_cast<Label*>(GetControl(IDC__LINE_LABEL5));
 456                 pLineLabel1->SetShowState(false);
 457                 pKeysPanel = null;
 458         }
 459 }
 460
 461 void
 462 ConfCallerListForm::ActivatePanels(void)
 463 {
 464         IListT<CallInfo>* pCallList = __pConfCallInfo->GetCallerList();
 465         int confCallCount = pCallList->GetCount();
 466
 467         for (int index = 0; index < confCallCount; index++)
 468         {
 469                 CallInfo callInfo;
 470                 String pContactNo;
 471                 result r = pCallList->GetAt(index, callInfo);
 472
 473                 pContactNo.Append(callInfo.GetContactNumber());
 474                 //fetch contact details based on phone number
 475                 String* pDisplayName = callInfo.FetchCallerNameN();
 476
 477                 if ((pDisplayName->IsEmpty()) || r != E_SUCCESS)
 478                 {
 479                         pDisplayName->Append(pContactNo);
 480                 }
 481
 482                 switch (index)
 483                 {
 484                 case 0:
 485                 {
 486                         ActivatePanelAndAddActionListener(IDC_CALLER1_PANEL,IDC__LINE_LABEL1,IDC_SPLIT_CALLER1,IDC_END_CALLER1
 487                                         ,IDC_CALLER1_LABEL,IDA_SPLIT_CALLER1,IDA_END_CALLER1,*pDisplayName);
 488                 }
 489                 break;
 490
 491                 case 1:
 492                 {
 493                         ActivatePanelAndAddActionListener(IDC_CALLER2_PANEL,IDC__LINE_LABEL2,IDC_SPLIT_CALLER2,IDC_END_CALLER2
 494                                         ,IDC_CALLER2_LABEL,IDA_SPLIT_CALLER2,IDA_END_CALLER2,*pDisplayName);
 495                 }
 496                 break;
 497
 498                 case 2:
 499                 {
 500                         ActivatePanelAndAddActionListener(IDC_CALLER3_PANEL,IDC__LINE_LABEL3,IDC_SPLIT_CALLER3,IDC_END_CALLER3
 501                                         ,IDC_CALLER3_LABEL,IDA_SPLIT_CALLER3,IDA_END_CALLER3,*pDisplayName);
 502                 }
 503                 break;
 504
 505                 case 3:
 506                 {
 507                         ActivatePanelAndAddActionListener(IDC_CALLER4_PANEL,IDC__LINE_LABEL4,IDC_SPLIT_CALLER4,IDC_END_CALLER4
 508                                         ,IDC_CALLER4_LABEL,IDA_SPLIT_CALLER4,IDA_END_CALLER4,*pDisplayName);
 509                 }
 510                 break;
 511
 512                 case 4:
 513                 {
 514                         ActivatePanelAndAddActionListener(IDC_CALLER5_PANEL,IDC__LINE_LABEL5,IDC_SPLIT_CALLER5,IDC_END_CALLER5
 515                                         ,IDC_CALLER5_LABEL,IDA_SPLIT_CALLER5,IDA_END_CALLER5,*pDisplayName);
 516                 }
 517                 break;
 518
 519                 default:
 520                         break;
 521                 }
 522
 523                 delete pDisplayName;
 524                 pDisplayName = null;
 525         }
 526 }
 527
 528 void
 529 ConfCallerListForm::ActivatePanelAndAddActionListener( const String& panelName, const String& lineLabelName, const String& splitButtonName,
 530                 const String& endButtonName, const String& callerLabelName, SplitConfCallerCmdIds splitCmdId,
 531                 EndConfCallerCmdIds EndCmdId, const String& displayName)
 532 {
 533         Bitmap* pNormalSplitBitmap = null;
 534         Bitmap* pPressSplitBitmap = null;
 535         Bitmap* pNormalEndBitmap = null;
 536         Bitmap* pPressEndBitmap = null;
 537
 538         pNormalSplitBitmap = AppUtility::GetBitmapFromResourcesN(IDB_SPLIT_NORMAL_BUTTON_ICON,
 539                         W_SPLIT_BITMAP, H_SPLIT_BITMAP);
 540         pPressSplitBitmap = AppUtility::GetBitmapFromResourcesN(IDB_SPLIT_PRESS_BUTTON_ICON,
 541                         W_SPLIT_BITMAP, H_SPLIT_BITMAP);
 542         pNormalEndBitmap = AppUtility::GetBitmapFromResourcesN(IDB_END_NORMAL_BUTTON_ICON,
 543                         W_END_BITMAP, H_END_BITMAP);
 544         pPressEndBitmap = AppUtility::GetBitmapFromResourcesN(IDB_END_PRESS_BUTTON_ICON,
 545                         W_END_BITMAP, H_END_BITMAP);
 546
 547         bool isSplitAllowed = true;
 548         if ((__pCallPresentor->IsSplitAllowed() == false) || (__pConfCallInfo->IsOnHold() == true))
 549         {
 550                 isSplitAllowed = false;
 551         }
 552
 553         Panel* pKeysPanel = static_cast<Panel*>(GetControl(panelName));
 554         if (pKeysPanel != null)
 555         {
 556                 Button* pButtonSplit = static_cast<Button*>(pKeysPanel->GetControl(splitButtonName));
 557                 if (pButtonSplit != null)
 558                 {
 559                         pButtonSplit->SetActionId(splitCmdId);
 560                         pButtonSplit->AddActionEventListener(*this);
 561                         pButtonSplit->SetNormalBitmap(Point(0, 0), *pNormalSplitBitmap);
 562                         pButtonSplit->SetPressedBitmap(Point(0, 0), *pPressSplitBitmap);
 563                 }
 564                 Button* pButtonEnd = static_cast<Button*>(pKeysPanel->GetControl(endButtonName));
 565                 if (pButtonEnd != null)
 566                 {
 567                         pButtonEnd->SetActionId(EndCmdId);
 568                         pButtonEnd->AddActionEventListener(*this);
 569                         pButtonEnd->SetNormalBitmap(Point(0, 0), *pNormalEndBitmap);
 570                         pButtonEnd->SetPressedBitmap(Point(0, 0), *pPressEndBitmap);
 571                 }
 572                 Label* pNameLabel = static_cast<Label*>(pKeysPanel->GetControl(callerLabelName));
 573                 if (pButtonSplit != null)
 574                 {
 575                         if (isSplitAllowed == false)
 576                         {
 577                                 pButtonSplit->SetShowState(false);
 578                                 pNameLabel->SetBounds(pButtonSplit->GetBounds().x, pNameLabel->GetBounds().y,
 579                                                 pNameLabel->GetBounds().width, pNameLabel->GetBounds().height);
 580                         }
 581                         else
 582                         {
 583                                 pButtonSplit->SetShowState(true);
 584                                 pNameLabel->SetBounds((pButtonSplit->GetBounds().x + pButtonSplit->GetBounds().width), pNameLabel->GetBounds().y,
 585                                                 pNameLabel->GetBounds().width, pNameLabel->GetBounds().height);
 586                         }
 587                 }
 588                 pNameLabel->SetText(displayName);
 589
 590                 pKeysPanel->SetShowState(true);
 591                 Label* pLineLabel1 = static_cast<Label*>(GetControl(lineLabelName));
 592                 pLineLabel1->SetShowState(true);
 593
 594                 pKeysPanel->Draw(true);
 595                 pKeysPanel->Show();
 596         }
 597
 598         delete pNormalEndBitmap;
 599         pNormalEndBitmap = null;
 600         delete pPressEndBitmap;
 601         pPressEndBitmap = null;
 602         delete pNormalSplitBitmap;
 603         pNormalSplitBitmap = null;
 604         delete pPressSplitBitmap;
 605         pPressSplitBitmap = null;
 606 }
 607
 608 void
 609 ConfCallerListForm::ShowTimerInfo(const String& timerLblName, long long startTime)
 610 {
 611         Label* pTimerLbl = static_cast<Label*>(GetControl(timerLblName));
 612
 613         if (__pConfCallTimer == null)
 614         {
 615                 __pConfCallTimer = new (std::nothrow) Timer();
 616                 __pConfCallTimer->Construct(*this);
 617         }
 618
 619         if (pTimerLbl != null)
 620         {
 621                 //current system time
 622                 long long currTime = 0;
 623                 SystemTime::GetTicks(currTime);
 624                 //Set call duration
 625                 TimeSpan diffSpan(abs(startTime - currTime));
 626
 627                 String activeCallTime(L"");
 628
 629                 long long hr = diffSpan.GetHours();
 630                 if (hr <= 9) {
 631                         activeCallTime.Append("0");
 632                 }
 633                 activeCallTime.Append(hr);
 634                 activeCallTime.Append(L":");
 635
 636                 long long min = diffSpan.GetMinutes();
 637                 if (min <= 9) {
 638                         activeCallTime.Append("0");
 639                 }
 640                 activeCallTime.Append(min);
 641                 activeCallTime.Append(L":");
 642
 643                 long long sec = diffSpan.GetSeconds();
 644                 if (sec <= 9) {
 645                         activeCallTime.Append("0");
 646                 }
 647                 activeCallTime.Append(sec);
 648
 649                 pTimerLbl->SetText(activeCallTime);
 650                 __pConfCallTimer->StartAsRepeatable(TimeSpan::NUM_OF_TICKS_IN_SECOND);
 651
 652         }
 653 }
 654
 655 void
 656 ConfCallerListForm::OnTimerExpired(Tizen::Base::Runtime::Timer& timer)
 657 {
 658         //Call default implementation of "Object.Equals()"
 659         //returns true, if they are pointing to same address.
 660         if (__pConfCallTimer->Equals(timer))
 661         {
 662                 Label* pTimerLbl = static_cast<Label*>(GetControl(IDC_CALL_TIME_LABEL));
 663                 if (pTimerLbl)
 664                 {
 665                         String activeCallTime = pTimerLbl->GetText();
 666                         // Create a StringTokenizer instance
 667                         StringTokenizer strTokens(activeCallTime, L":");
 668
 669                         int count = strTokens.GetTokenCount(); // count == 3
 670                         String token;
 671                         int sec = 0;
 672                         int min = 0;
 673                         int hr = 0;
 674                         for (int index = 0; index < count; index++)
 675                         {
 676                                 switch (index)
 677                                 {
 678                                 case 0:
 679                                         strTokens.GetNextToken(token);
 680                                         Integer::Parse(token, hr);
 681                                         break;
 682
 683                                 case 1:
 684                                         strTokens.GetNextToken(token);
 685                                         Integer::Parse(token, min);
 686                                         break;
 687
 688                                 case 2:
 689                                         strTokens.GetNextToken(token);
 690                                         Integer::Parse(token, sec);
 691                                         break;
 692                                 }
 693                         }
 694                         //update all values
 695                         sec = sec + 1;
 696                         if (sec == IDI_MAX_SECONDS)
 697                         {
 698                                 sec = 0;
 699                                 min = min + 1;
 700                         }
 701                         if (min == IDI_MAX_MINS)
 702                         {
 703                                 min = 0;
 704                                 hr = hr + 1;
 705                         }
 706
 707                         //replace string
 708                         activeCallTime.Clear();
 709                         if (hr <= 9)
 710                         {
 711                                 activeCallTime.Append("0");
 712                         }
 713                         activeCallTime.Append(hr);
 714                         activeCallTime.Append(":");
 715                         if (min <= 9)
 716                         {
 717                                 activeCallTime.Append("0");
 718                         }
 719                         activeCallTime.Append(min);
 720                         activeCallTime.Append(":");
 721                         if (sec <= 9)
 722                         {
 723                                 activeCallTime.Append("0");
 724                         }
 725                         activeCallTime.Append(sec);
 726                         //update timer label
 727                         pTimerLbl->SetText(activeCallTime);
 728                         pTimerLbl->Invalidate(true);
 729                 }
 730         }
 731 }