src/CallBaseForm.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        CallBaseForm.cpp
  19  * @brief       Base class for all Call forms
  20  */
  21 #include "CallActiveCallForm.h"
  22 #include "CallIncomingCallForm.h"
  23 #include "CallBaseForm.h"
  24 #include "CallInfo.h"
  25 #include "CallPresentationModel.h"
  26 #include "CallConfCallerListForm.h"
  27 #include "CallPhoneFormFactory.h"
  28 #include "CallSceneRegister.h"
  29 #include "CallApp.h"
  30
  31 using namespace Tizen::App;
  32 using namespace Tizen::Base;
  33 using namespace Tizen::Ui;
  34 using namespace Tizen::Base::Collection;
  35 using namespace Tizen::Ui;
  36 using namespace Tizen::Ui::Scenes;
  37 using namespace Tizen::Ui::Controls;
  38
  39 BaseForm::BaseForm(FormType formType)
  40                 : __formType(formType)
  41 {
  42         __pCallPresentor = null;
  43         __pErrorMsgPopup = null;
  44 }
  45
  46 BaseForm::~BaseForm(void)
  47 {
  48 }
  49
  50 result
  51 BaseForm::OnInitializing(void)
  52 {
  53         //To be implemented in sub classes
  54         return E_SUCCESS;
  55 }
  56
  57 void
  58 BaseForm::OnActionPerformed(const Control& source, int actionId)
  59 {
  60 }
  61
  62 /////////////////////////////////////////////////////////////////
  63 /////  Event Listener methods from ITelephonyEventListener  /////
  64 /////////////////////////////////////////////////////////////////
  65
  66 void
  67 BaseForm::HandleCallConnected(IListT<AppCallInfo>& pCallList)
  68 {
  69         if(__pCallPresentor->IsIncomingorDialingCallPresent() == true)
  70         {
  71                 //This scenario will come, if 1 call is disconnected from conf. call having 2 participants.
  72                 //In this case, if there is any dialing call exists, then ignore.
  73                 //Else, if there is any incoming call exists, then update call option popup.
  74                 switch (__formType)
  75                 {
  76                 case FORMTYPE_INCOMINGCALL:
  77                 {
  78                         IncomingCallForm* pIncomingCallForm = dynamic_cast<IncomingCallForm*>(this);
  79                         if (pIncomingCallForm != null)
  80                         {
  81                                 pIncomingCallForm->CallDisconnected();
  82                         }
  83                 }
  84                         break;
  85
  86                 default:
  87                         break;
  88                 }
  89                 return;
  90         }
  91
  92         SceneManager* pSceneManager = SceneManager::GetInstance();
  93
  94         switch (__formType)
  95         {
  96         case FORMTYPE_OUTGOINGCALL:
  97         case FORMTYPE_INCOMINGCALL:
  98         case FORMTYPE_CONFCALLLIST:
  99         case FORMTYPE_ACTIVECALL:
 100         case FORMTYPE_ACTIVECONFCALL:
 101         {
 102                 int noOfCalls = pCallList.GetCount();
 103                 //Ownership - To be deleted in 'OnSceneActivatedN' of next form
 104                 ArrayList* pCallInfoList = new (std::nothrow) ArrayList(SingleObjectDeleter);
 105                 pCallInfoList->Construct(noOfCalls);
 106
 107                 for (int index = 0; index < noOfCalls; index++)
 108                 {
 109                         //fetch call info and add to list
 110                         AppCallInfo callInfo;
 111                         result r = pCallList.GetAt(index, callInfo);
 112                         if (r == E_SUCCESS)
 113                         {
 114                                 //copy call information to new instance
 115                                 AppCallInfo* pCaller = new (std::nothrow) AppCallInfo();
 116                                 *pCaller = callInfo;
 117                                 pCallInfoList->Add(pCaller);
 118                         }
 119                 }
 120
 121                 if (noOfCalls == 1)
 122                 {
 123                         //Check if active call is conference call
 124                         AppCallInfo* pActiveCallInfo = static_cast<AppCallInfo*>(pCallInfoList->GetAt(0));
 125                         if(pActiveCallInfo->IsConferenceCall() == true)
 126                         {
 127                                 //single Conference call - goto active Conf. call form
 128                                 pSceneManager->GoForward(ForwardSceneTransition(IDSCN_SCENE_CONFCALL), pCallInfoList);
 129                         }
 130                         else
 131                         {
 132                                 //single active call - goto active call form
 133                                 pSceneManager->GoForward(ForwardSceneTransition(IDSCN_SCENE_ACTIVECALL), pCallInfoList);
 134                         }
 135                 }
 136                 else if(noOfCalls == 2)
 137                 {
 138                         //goto multiple active call form
 139                         pSceneManager->GoForward(ForwardSceneTransition(IDSCN_SCENE_MULTIPLEACTIVECALL), pCallInfoList);
 140                 }
 141         }
 142         break;
 143
 144         case FORMTYPE_MULTIPLECALLS:
 145         {
 146                 //This case can come on Multiple Calls screen, when one of the calls is conference call with 2 participants
 147                 //and one of the participants exits himself from ConfCall.
 148                 int noOfCalls = pCallList.GetCount();
 149                 AppLogDebug("Active Call Count = %d", noOfCalls);
 150                 //this is just a safety check, call count will aleays be 2 here.
 151                 ActiveCallForm* pActiveCallForm = dynamic_cast<ActiveCallForm*>(this);
 152                 if(noOfCalls == IDI_MAX_ACTIVE_CALLS && pActiveCallForm != null)
 153                 {
 154                         //update calls state
 155                         pActiveCallForm->UpdateMultipleCallScreen(pCallList);
 156                 }
 157         }
 158         break;
 159
 160         case FORMTYPE_EMERGENCYOUTGOINGCALL:
 161         {
 162                 //Ownership - To be deleted in 'OnSceneActivatedN' of next form
 163                 ArrayList* pCallInfoList = new (std::nothrow) ArrayList(SingleObjectDeleter);
 164                 pCallInfoList->Construct(1);
 165
 166                 //fetch call info and add to list
 167                 AppCallInfo callInfo;
 168                 result r = pCallList.GetAt(0, callInfo);
 169                 if (r == E_SUCCESS)
 170                 {
 171                         //copy call information to new instance
 172                         AppCallInfo* pCaller = new (std::nothrow) AppCallInfo();
 173                         *pCaller = callInfo;
 174                         pCallInfoList->Add(pCaller);
 175                         //single active call - goto active call form
 176                         pSceneManager->GoForward(ForwardSceneTransition(IDSCN_SCENE_ACTIVE_EMERGENCYCALL), pCallInfoList);
 177                 }
 178         }
 179         break;
 180
 181         default:
 182                 break;
 183         }
 184 }
 185
 186 void
 187 BaseForm::HandleCallDisconnected(bool isLastCall, IListT<AppCallInfo>& pCurrentActiveCallList)
 188 {
 189         if(__pCallPresentor->IsIncomingorDialingCallPresent() == true)
 190         {
 191                 //This scenario will come, if this disconnected call is neither incoming nor dialing call.
 192                 //In this case, if there is any dialing call exists, then ignore.
 193                 //Else, if there is any incoming call exists, then update call option popup.
 194                 switch (__formType)
 195                 {
 196                 case FORMTYPE_INCOMINGCALL:
 197                 {
 198                         IncomingCallForm* pIncomingCallForm = dynamic_cast<IncomingCallForm*>(this);
 199                         if (pIncomingCallForm != null)
 200                         {
 201                                 pIncomingCallForm->CallDisconnected();
 202                         }
 203                 }
 204                         break;
 205
 206                 default:
 207                         break;
 208                 }
 209                 return;
 210         }
 211
 212         SceneManager* pSceneManager = SceneManager::GetInstance();
 213         CallApp* pPhoneApp = static_cast<CallApp*>(UiApp::GetInstance());
 214
 215         int callCount = pCurrentActiveCallList.GetCount();
 216         if (callCount > 0)
 217         {
 218                 //Ownership - To be deleted in 'OnSceneActivatedN' of next form
 219                 ArrayList* pCallInfoList = new (std::nothrow) ArrayList(SingleObjectDeleter);
 220                 pCallInfoList->Construct(callCount);
 221                 for (int index = 0; index < callCount; index++)
 222                 {
 223                         //fetch call info and add to list
 224                         AppCallInfo callInfo;
 225                         result r = pCurrentActiveCallList.GetAt(index, callInfo);
 226                         if (r == E_SUCCESS)
 227                         {
 228                                 //copy call information to new instance
 229                                 AppCallInfo* pCaller = new (std::nothrow) AppCallInfo();
 230                                 *pCaller = callInfo;
 231                                 pCallInfoList->Add(pCaller);
 232                         }
 233                 }
 234                 if (callCount == 1)
 235                 {
 236                         //fetch call info and add to list
 237                         AppCallInfo callInfo;
 238                         result r = pCurrentActiveCallList.GetAt(0, callInfo);
 239                         if (r == E_SUCCESS)
 240                         {
 241                                 //copy call information to new instance
 242                                 AppCallInfo* pCaller = new (std::nothrow) AppCallInfo();
 243                                 *pCaller = callInfo;
 244                                 pCallInfoList->Add(pCaller);
 245                         }
 246
 247                         if (isLastCall == true)
 248                         {
 249                                 //goto End Call form if single call. else terminate
 250                                 if (callInfo.IsConferenceCall() == false)
 251                                 {
 252                                         pSceneManager->GoForward(ForwardSceneTransition(IDSCN_SCENE_ENDCALL), pCallInfoList);
 253                                 }
 254                                 else
 255                                 {
 256                                         pPhoneApp->Terminate();
 257                                 }
 258                         }
 259                         else
 260                         {
 261                                 if (pCurrentActiveCallList.GetCount() == 1)
 262                                 {
 263                                         if (callInfo.IsConferenceCall() == true)
 264                                         {
 265                                                 pSceneManager->GoForward(ForwardSceneTransition(IDSCN_SCENE_CONFCALL), pCallInfoList);
 266                                         }
 267                                         else
 268                                         {
 269                                                 //goto Single Active Call form
 270                                                 pSceneManager->GoForward(ForwardSceneTransition(IDSCN_SCENE_ACTIVECALL), pCallInfoList);
 271                                         }
 272                                 }
 273                         }
 274                 }
 275                 else
 276                 {
 277                         pSceneManager->GoForward(ForwardSceneTransition(IDSCN_SCENE_MULTIPLEACTIVECALL), pCallInfoList);
 278                 }
 279         }
 280         else
 281         {
 282                 pPhoneApp->Terminate();
 283         }
 284 }
 285
 286
 287 void
 288 BaseForm::HandleConferenceCall(AppCallInfo& pCallInfo)
 289 {
 290         SceneManager* pSceneManager = SceneManager::GetInstance();
 291
 292         //Ownership - To be deleted in 'OnSceneActivatedN' of next form
 293         ArrayList* pCallInfoList = new (std::nothrow) ArrayList(SingleObjectDeleter);
 294         pCallInfoList->Construct(1);
 295
 296         //update list to be passed
 297         AppCallInfo* pConfInfo = new (std::nothrow) AppCallInfo();
 298         *pConfInfo = pCallInfo;
 299         pCallInfoList->Add(pConfInfo);
 300
 301         //Todo: create screens for single conf call and conf call with another held call
 302         pSceneManager->GoForward(ForwardSceneTransition(IDSCN_SCENE_CONFCALL), pCallInfoList);
 303 }
 304
 305 void
 306 BaseForm::HandleIncomingCall(AppCallInfo& pCallInfo)
 307 {
 308         SceneManager* pSceneManager = SceneManager::GetInstance();
 309
 310         //Ownership - To be deleted in 'OnSceneActivatedN' of next form
 311         ArrayList* pCallInfoList = new (std::nothrow) ArrayList(SingleObjectDeleter);
 312         pCallInfoList->Construct(1);
 313
 314         //update list to be passed
 315         AppCallInfo* pIncomingCall = new (std::nothrow) AppCallInfo();
 316         *pIncomingCall = pCallInfo;
 317         pCallInfoList->Add(pIncomingCall);
 318
 319         pSceneManager->GoForward(ForwardSceneTransition(IDSCN_SCENE_INCOMINGCALL), pCallInfoList);
 320 }
 321
 322 void
 323 BaseForm::HandleCallSwapOccured(IListT<AppCallInfo>& pCallList)
 324 {
 325         int noOfCalls = pCallList.GetCount();
 326         if(noOfCalls != IDI_MAX_ACTIVE_CALLS && __formType != FORMTYPE_MULTIPLECALLS)
 327         {
 328                 return;
 329         }
 330         ActiveCallForm* pActiveCallForm = dynamic_cast<ActiveCallForm*>(this);
 331         if(pActiveCallForm != null)
 332         {
 333                 //update calls state
 334                 pActiveCallForm->UpdateMultipleCallScreen(pCallList);
 335         }
 336 }
 337
 338 void
 339 BaseForm::HandleConferenceChange(void)
 340 {
 341         if(__pCallPresentor->IsIncomingorDialingCallPresent() == true)
 342         {
 343                 //This scenario will come, if 1 call is disconnected from conf. call having more than 2 participants.
 344                 //In this case, if there is any dialing call exists, then ignore.
 345                 //Else, if there is any incoming call exists, then update call option popup.
 346                 switch (__formType)
 347                 {
 348                 case FORMTYPE_INCOMINGCALL:
 349                 {
 350                         IncomingCallForm* pIncomingCallForm = dynamic_cast<IncomingCallForm*>(this);
 351                         if (pIncomingCallForm != null)
 352                         {
 353                                 pIncomingCallForm->CallDisconnected();
 354                         }
 355                 }
 356                         break;
 357
 358                 default:
 359                         break;
 360                 }
 361                 return;
 362         }
 363
 364         switch (__formType)
 365         {
 366         case FORMTYPE_CONFCALLLIST:
 367         {
 368                 ConfCallerListForm* pConfCallerListForm = dynamic_cast<ConfCallerListForm*>(this);
 369                 if(pConfCallerListForm != null)
 370                 {
 371                         pConfCallerListForm->HandleParticipantsChanged();
 372                 }
 373         }
 374                 break;
 375
 376         case FORMTYPE_ACTIVECONFCALL:
 377         case FORMTYPE_MULTIPLECALLS:
 378         {
 379                 ActiveCallForm* pActiveCallForm = dynamic_cast<ActiveCallForm*>(this);
 380                 if(pActiveCallForm != null)
 381                 {
 382                         pActiveCallForm->HandleConfCallChanged();
 383                 }
 384         }
 385                 break;
 386         default:
 387                 break;
 388         }
 389 }
 390
 391 void
 392 BaseForm::HandleTelephonyError(int errorCode)
 393 {
 394         //show error msg Popup
 395         if (__pErrorMsgPopup == null)
 396         {
 397                 __pErrorMsgPopup = new (std::nothrow) ErrorMsgPopup(this);
 398                 __pErrorMsgPopup->ShowErrorMsgPopupN(errorCode);
 399         }
 400 }
 401
 402 void
 403 BaseForm::HandlePopupClosed(void)
 404 {
 405         Draw();
 406         delete __pErrorMsgPopup;
 407         __pErrorMsgPopup = null;
 408
 409         switch(__formType)
 410         {
 411         case FORMTYPE_OUTGOINGCALL:
 412         {
 413                 //fetch no of calls from telephony
 414                 CallPresentationModel* pPresentor = CallPresentationModel::GetInstance();
 415                 if(pPresentor != null)
 416                 {
 417                         //check if any call is present
 418                         if(pPresentor->GetCurrentCallCount() > 0)
 419                         {
 420                                 //fetch current call list
 421                                 IListT<AppCallInfo>* pCurrentCallList = pPresentor->GetCallListN();
 422                                 HandleCallDisconnected(false,*pCurrentCallList);
 423                                 delete pCurrentCallList;
 424                                 pCurrentCallList = null;
 425                         }
 426                         else
 427                         {
 428                                 //No more calls are active
 429                                 CallApp* pPhoneApp = static_cast<CallApp*>(UiApp::GetInstance());
 430                                 pPhoneApp->Terminate();
 431
 432                         }
 433                 }
 434         }
 435         break;
 436
 437         case FORMTYPE_ENDCALL:
 438         {
 439                 //It comes here, only when we make voice call for Last call from EndCallForm
 440                 //and some TAPI error is encountered.
 441                 CallApp* pPhoneApp = static_cast<CallApp*>(UiApp::GetInstance());
 442                 pPhoneApp->Terminate();
 443         }
 444         break;
 445
 446         default:
 447         break;
 448         }
 449 }
 450