src/FTel_CallManagerImpl.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17 /**
  18  * @file    FTel_CallManagerImpl.cpp
  19  * @brief   This is the implementation file for _CallManagerImpl class.
  20  */
  21
  22 #include <string.h>
  23 #include <glib.h>
  24 #include <tapi_common.h>
  25 #include <tapi_event.h>
  26 #include <TapiUtility.h>
  27 #include <ITapiCall.h>
  28 #include <FBaseString.h>
  29 #include <FBaseUtilStringUtil.h>
  30 #include <FTelITelephonyCallEventListener.h>
  31 #include <FTelITelephonyCallForwardListener.h>
  32 #include <FTelCallManager.h>
  33 #include <FBaseSysLog.h>
  34 #include "FTel_CallInfoImpl.h"
  35 #include "FTel_CallManagerImpl.h"
  36 #include "FTel_CallManagerEvent.h"
  37 #include "FTel_CallManagerEventArg.h"
  38 #include "FTel_CallForwardEvent.h"
  39 #include "FTel_CallForwardEventArg.h"
  40 #include "FTel_TelephonyIpcProxy.h"
  41 #include "FTel_NetworkManagerImpl.h"
  42
  43 using namespace std;
  44 using namespace Tizen::App;
  45 using namespace Tizen::Base;
  46 using namespace Tizen::Base::Utility;
  47
  48
  49 namespace Tizen { namespace Telephony
  50 {
  51
  52 _CallManagerImpl::_CallManagerImpl(void)
  53         : __pCallEventListener(null)
  54         , __pCallForwardListener(null)
  55         , __pHandle(null)
  56         , __callFwdSubscriptionId(0)
  57         , __callFwdStatusSubscriptionId(0)
  58         , __callFwdReqId(INVALID_REQUEST_ID)
  59         , __callFwdReqNumId(INVALID_REQUEST_ID)
  60         , __isReqCallFwdNumInProgress(false)
  61         , __curCallState(CALL_STATUS_IDLE)
  62         , __curCallFwdState(_CALL_FORWARD_IDLE)
  63     , __pCallManagerEvent(null)
  64     , __pCallForwardEvent(null)
  65
  66 {
  67         __pCallEventType[_CALL_NOTI_VOICE_CALL_IDLE] = TAPI_NOTI_VOICE_CALL_STATUS_IDLE;
  68         __pCallEventType[_CALL_NOTI_VOICE_CALL_COMMUNICATING] = TAPI_NOTI_VOICE_CALL_STATUS_ACTIVE;
  69         __pCallEventType[_CALL_NOTI_VOICE_CALL_RINGING] = TAPI_NOTI_VOICE_CALL_STATUS_INCOMING;
  70         __pCallEventType[_CALL_NOTI_VOICE_CALL_DIALING] = TAPI_NOTI_VOICE_CALL_STATUS_DIALING;
  71         __pCallEventType[_CALL_NOTI_VOICE_CALL_HOLDING] = TAPI_NOTI_VOICE_CALL_STATUS_HELD;
  72         __pCallEventType[_CALL_NOTI_VIDEO_CALL_IDLE] = TAPI_NOTI_VIDEO_CALL_STATUS_IDLE;
  73         __pCallEventType[_CALL_NOTI_VIDEO_CALL_COMMUNICATING] = TAPI_NOTI_VIDEO_CALL_STATUS_ACTIVE;
  74         __pCallEventType[_CALL_NOTI_VIDEO_CALL_RINGING] = TAPI_NOTI_VIDEO_CALL_STATUS_INCOMING;
  75         __pCallEventType[_CALL_NOTI_VIDEO_CALL_DIALING] = TAPI_NOTI_VIDEO_CALL_STATUS_DIALING;
  76         __pCallEventType[_CALL_NOTI_PEER_CALL_HELD] = TAPI_NOTI_CALL_INFO_HELD;
  77         __pCallEventType[_CALL_NOTI_PEER_CALL_RETRIEVED] = TAPI_NOTI_CALL_INFO_ACTIVE;
  78
  79 }
  80
  81 _CallManagerImpl::~_CallManagerImpl(void)
  82 {
  83         if (__pHandle != null)
  84         {
  85                 for (int i = 0; i < _CALL_NOTI_MAX; i++)
  86                 {
  87                         tel_deregister_noti_event(__pHandle, __pCallEventType[i]);
  88         }
  89
  90                 tel_deinit(__pHandle);
  91         }
  92 }
  93
  94 result
  95 _CallManagerImpl::Construct(ITelephonyCallEventListener* pListener)
  96 {
  97         SysLog(NID_TEL, "The current call state is %s", GetStringOfCallState());
  98
  99         result r = E_SUCCESS;
 100         int err = TAPI_API_SUCCESS;
 101
 102         __pHandle = tel_init(null);
 103         SysTryCatch(NID_TEL, __pHandle != null, r = E_SYSTEM, E_SYSTEM, "[%s] A system error has occurred. Failed to initialize TApi library.", GetErrorMessage(E_SYSTEM));
 104
 105         if (pListener != null)
 106         {
 107                 for (int i = 0; i < _CALL_NOTI_MAX; i++)
 108                 {
 109                         err = tel_register_noti_event(__pHandle, __pCallEventType[i], OnCallStatusChangedCallback, this);
 110                         SysLog(NID_TEL, "The registered call type is %s", GetStringOfCallEventType(_CALL_NOTI_VOICE_CALL_IDLE + i));
 111
 112                         SysTryCatch(NID_TEL, err == TAPI_API_SUCCESS, r = E_SYSTEM, E_SYSTEM,
 113                                 "[%s] A system error has occurred. Failed to register the callback function.", GetErrorMessage(E_SYSTEM));
 114                 }
 115
 116                 unique_ptr<_CallManagerEvent> pCallManagerEvent(new (std::nothrow) _CallManagerEvent);
 117         SysTryReturnResult(NID_TEL, pCallManagerEvent != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
 118
 119         r = pCallManagerEvent->Construct();
 120         SysTryReturnResult(NID_TEL, r != E_OUT_OF_MEMORY, r, "Propagating.");
 121         SysTryReturnResult(NID_TEL, r == E_SUCCESS, E_SYSTEM, "A system error has occurred. Failed to construct CallManagerEvent.");
 122
 123         pCallManagerEvent->AddListener(*pListener, true);
 124
 125         __pCallManagerEvent = move(pCallManagerEvent);
 126
 127         }
 128
 129         r = InitializeInternalCallStatus();
 130         SysTryCatch(NID_TEL, r == E_SUCCESS, , E_SYSTEM, "[%s] A system error has occurred. Failed to initialize internal call state.", GetErrorMessage(E_SYSTEM));
 131
 132         __pTelephonyServiceProxy = _TelephonyIpcProxy::GetInstance();
 133
 134         if (__pTelephonyServiceProxy == null)
 135     {
 136         SysLog(NID_TEL, "Creating an IPC instance to connect with the Connectivity service daemon has failed.");
 137     }
 138
 139         return r;
 140
 141 CATCH:
 142         for (int i = 0; i < _CALL_NOTI_MAX; i++)
 143         {
 144                     tel_deregister_noti_event(__pHandle, __pCallEventType[i]);
 145         }
 146
 147         if (__pHandle != null)
 148         {
 149                 tel_deinit(__pHandle);
 150             __pHandle = null;
 151         }
 152
 153         return r;
 154 }
 155
 156 result
 157 _CallManagerImpl::SetCallForwardListener(ITelephonyCallForwardListener* pListener)
 158 {
 159         SysTryReturnResult(NID_TEL, __pTelephonyServiceProxy != null, E_SYSTEM, "A system error has occurred. IPC instance has not been constructed yet.");
 160
 161         result r = __pTelephonyServiceProxy->HasCallForwardPrivilege();
 162         SysTryReturnResult(NID_TEL, r == E_SUCCESS, r, "Propagating.");
 163
 164         if (__pCallForwardListener != null)
 165     {
 166             __pCallForwardEvent->RemoveListener(*__pCallForwardListener);
 167             __pCallForwardListener = null;
 168     }
 169
 170
 171         // Creates event object
 172     if (__pCallForwardEvent == null && pListener != null)
 173     {
 174         std::unique_ptr<_CallForwardEvent> pCallForwardEvent(new (std::nothrow) _CallForwardEvent());
 175
 176          SysTryReturnResult(NID_TEL, pCallForwardEvent != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
 177
 178          r = pCallForwardEvent->Construct();
 179          SysTryReturnResult(NID_TEL, r == E_SUCCESS, r, "Propagating.");
 180
 181          __pCallForwardEvent = move(pCallForwardEvent);
 182     }
 183
 184     // Adds listener
 185     if (pListener != null)
 186     {
 187         __pCallForwardListener = pListener;
 188         r = __pCallForwardEvent->AddListener(*__pCallForwardListener, true);
 189     }
 190
 191     if (r != E_SUCCESS)
 192     {
 193         __pCallForwardEvent.reset(null);
 194                 SysLogException(NID_TEL, r, "[%s] Propagating.", GetErrorMessage(r));
 195     }
 196
 197     return r;
 198 }
 199
 200 result
 201 _CallManagerImpl::RequestCallForward(const String& phoneNumber)
 202 {
 203         result r = E_SUCCESS;
 204
 205         switch (__curCallFwdState)
 206         {
 207         case _CALL_FORWARD_REQUESTING:
 208         {
 209                 SysLogException(NID_TEL, E_IN_PROGRESS, "[%s] The previous request is in progress.", GetErrorMessage(E_IN_PROGRESS));
 210                 return E_IN_PROGRESS;
 211         }
 212
 213         case  _CALL_FORWARD_ON_SERVICE:
 214         case  _CALL_FORWARD_STOPPING:
 215         {
 216             SysLogException(NID_TEL, E_INVALID_STATE, "[%s] The current state of the instance prohibits the execution of this operation.", GetErrorMessage(E_IN_PROGRESS));
 217                 return E_INVALID_STATE;
 218         }
 219
 220         default:
 221                 break;
 222         }
 223
 224         SysLog(NID_TEL, "The phonenumber is %ls", phoneNumber.GetPointer());
 225
 226         SysTryReturnResult(NID_TEL, _NetworkManagerImpl::IsNetworkAvailable(), E_NETWORK_UNAVAILABLE,
 227                                           "The operation failed because the device is in the offline mode.");
 228         SysTryReturnResult(NID_TEL,  _NetworkManagerImpl::IsServiceAvailable(), E_SERVICE_UNAVAILABLE,
 229                                           "The operation failed because the device is out of the coverage area or in the emergency mode.");
 230         SysTryReturnResult(NID_TEL, !phoneNumber.IsEmpty(), E_INVALID_FORMAT, "The phone number is empty string.");
 231         SysTryReturnResult(NID_TEL, IsPhoneNumberValid(phoneNumber), E_INVALID_FORMAT, "The phone number is invalid format");
 232
 233         r = __pTelephonyServiceProxy->RequestCallForward(this, phoneNumber);
 234         SysTryReturnResult(NID_TEL, r == E_SUCCESS, r, "Propagating.");
 235
 236         __curCallFwdState = _CALL_FORWARD_REQUESTING;
 237
 238         return r;
 239 }
 240
 241 result
 242 _CallManagerImpl::StopCallForward(void)
 243 {
 244         switch (__curCallFwdState)
 245         {
 246         case _CALL_FORWARD_STOPPING:
 247         {
 248                 SysLogException(NID_TEL, E_IN_PROGRESS, "[%s] The previous request is in progress.", GetErrorMessage(E_IN_PROGRESS));
 249                 return E_IN_PROGRESS;
 250         }
 251         case _CALL_FORWARD_IDLE:
 252         case _CALL_FORWARD_REQUESTING:
 253         {
 254                 SysLogException(NID_TEL, E_INVALID_STATE, "[%s] The current state of the instance prohibits the execution of this operation.", GetErrorMessage(E_INVALID_STATE));
 255                 return E_INVALID_STATE;
 256         }
 257         default:
 258                 break;
 259         }
 260         SysTryReturnResult(NID_TEL, _NetworkManagerImpl::IsNetworkAvailable(), E_NETWORK_UNAVAILABLE,
 261                                           "The operation has failed because the device is in the offline mode.");
 262         SysTryReturnResult(NID_TEL, _NetworkManagerImpl::IsServiceAvailable(), E_SERVICE_UNAVAILABLE,
 263                           "The operation failed because the device is out of the coverage area or in the emergency mode.");
 264
 265         result r = __pTelephonyServiceProxy->StopCallForward(this);
 266         SysTryReturnResult(NID_TEL, r == E_SUCCESS, r, "Propagating.");
 267
 268         __curCallFwdState = _CALL_FORWARD_STOPPING;
 269
 270         return r;
 271 }
 272
 273 result
 274 _CallManagerImpl::GetCallForwardNumber(void)
 275 {
 276         SysTryReturnResult(NID_TEL, __pCallForwardListener != null, E_INVALID_OPERATION,
 277                                           "The ITelephonyCallForwardListener has not been registered yet.");
 278         SysTryReturnResult(NID_TEL, !__isReqCallFwdNumInProgress, E_IN_PROGRESS, "The previous request is in progress.");
 279         SysTryReturnResult(NID_TEL,  _NetworkManagerImpl::IsNetworkAvailable(), E_NETWORK_UNAVAILABLE,
 280                                           "The operation has failed because the device is in the offline mode.");
 281         SysTryReturnResult(NID_TEL, _NetworkManagerImpl::IsServiceAvailable(), E_SERVICE_UNAVAILABLE,
 282                                           "The operation failed because the device is out of the coverage area or in the emergency mode.");
 283
 284         result r = __pTelephonyServiceProxy->GetCallForwardNumber(this);
 285         SysTryReturnResult(NID_TEL, r == E_SUCCESS, r, "Propagating.");
 286
 287         __isReqCallFwdNumInProgress = true;
 288
 289         return r;
 290 }
 291
 292 CallType
 293 _CallManagerImpl::GetCurrentCallType(void) const
 294 {
 295         CallType type = TYPE_UNDEFINED_CALL;
 296         int err = TAPI_API_SUCCESS;
 297
 298         err = tel_get_call_status_all(__pHandle, OnCallTypeCallback, &type);
 299
 300         return type;
 301 }
 302
 303 CallStatus
 304 _CallManagerImpl::GetCurrentCallStatus(void) const
 305 {
 306         return __curCallState;
 307 }
 308
 309 void
 310 _CallManagerImpl::OnCallStatusChangedCallback(TapiHandle* pHandle, const char* pNotiId, void* pData, void* pUserData)
 311 {
 312         SysLog(NID_TEL, "The pNotiId value is %s", pNotiId);
 313
 314         CallType callType = TYPE_UNDEFINED_CALL;
 315         String phoneNumber;
 316         int callId = 0;
 317         int err = 0;
 318         _CallManagerImpl* pCallManagerImpl = static_cast <_CallManagerImpl*>(pUserData);
 319         pCallManagerImpl->__curCallState = CALL_STATUS_IDLE;
 320
 321         if (strcmp(pNotiId, TAPI_NOTI_VOICE_CALL_STATUS_IDLE) == 0
 322             || strcmp(pNotiId,TAPI_NOTI_VIDEO_CALL_STATUS_IDLE) == 0)
 323         {
 324             TelCallStatusIdleNoti_t* pNotiData = (TelCallStatusIdleNoti_t*)pData;
 325             callId = pNotiData->id;
 326
 327                 err = tel_get_call_status_all(pHandle, OnCallStatusCallback, pCallManagerImpl);
 328             SysLog(NID_TEL, "The tel_get_call_status_all() returned %d value", err);
 329         }
 330         else
 331         {
 332             if (strcmp(pNotiId, TAPI_NOTI_VOICE_CALL_STATUS_ACTIVE) == 0
 333                         || strcmp(pNotiId,TAPI_NOTI_VIDEO_CALL_STATUS_ACTIVE) == 0)
 334             {
 335                 TelCallStatusActiveNoti_t* pNotiData = (TelCallStatusActiveNoti_t*)pData;
 336                 callId = pNotiData->id;
 337             }
 338             else if (strcmp(pNotiId,TAPI_NOTI_VOICE_CALL_STATUS_INCOMING) == 0
 339                     || strcmp(pNotiId,TAPI_NOTI_VIDEO_CALL_STATUS_INCOMING) == 0)
 340             {
 341                 TelCallStatusIncomingNoti_t* pNotiData = (TelCallStatusIncomingNoti_t*)pData;
 342                 callId = pNotiData->id;
 343             }
 344             else if (strcmp(pNotiId,TAPI_NOTI_VOICE_CALL_STATUS_DIALING) == 0
 345                     || strcmp(pNotiId, TAPI_NOTI_VIDEO_CALL_STATUS_DIALING) == 0)
 346             {
 347                 TelCallStatusDialingNoti_t* pNotiData = (TelCallStatusDialingNoti_t*)pData;
 348                 callId = pNotiData->id;
 349             }
 350             else if (strcmp(pNotiId,TAPI_NOTI_VOICE_CALL_STATUS_HELD) == 0)
 351             {
 352                 TelCallStatusHeldNoti_t* pNotiData = (TelCallStatusHeldNoti_t*)pData;
 353                 callId = pNotiData->id;
 354             }
 355             else if (strcmp(pNotiId,TAPI_NOTI_CALL_INFO_HELD) == 0)
 356             {
 357                 TelCallInfoHeldNoti_t* pNotiData = (TelCallInfoHeldNoti_t*)pData;
 358                 callId = pNotiData->id;
 359             }
 360             else if (strcmp(pNotiId,TAPI_NOTI_CALL_INFO_ACTIVE) == 0)
 361             {
 362                 TelCallInfoActiveNoti_t* pNotiData = (TelCallInfoActiveNoti_t*)pData;
 363                 callId = pNotiData->id;
 364             }
 365
 366             err = tel_get_call_status_all(pHandle, OnCallStatusCallback, pCallManagerImpl);
 367             SysLog(NID_TEL, "The tel_get_call_status_all() returned %d value", err);
 368
 369             phoneNumber = pCallManagerImpl->GetPhoneNumber(pHandle, callId);
 370                 SysLog(NID_TEL, "The phonenumber is %ls", phoneNumber.GetPointer());
 371         }
 372
 373
 374         callType = pCallManagerImpl->GetCurrentCallType();
 375
 376         if (pCallManagerImpl->__curCallState != CALL_STATUS_UNDEFINED)
 377         {
 378                 unique_ptr<CallInfo> pCallInfo(null);
 379             _CallInfoImpl* pCallInfoImpl = null;
 380
 381             pCallInfo.reset(new (std::nothrow) CallInfo());
 382             SysTryReturnVoidResult(NID_TEL, pCallInfo != null, E_OUT_OF_MEMORY,
 383                         "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 384
 385             pCallInfoImpl = _CallInfoImpl::GetInstance(*pCallInfo);
 386             pCallInfoImpl->SetCallType(callType);
 387             pCallInfoImpl->SetNumber(phoneNumber);
 388
 389             _CallManagerEventArg* pEventArg = new (std::nothrow)_CallManagerEventArg(pCallManagerImpl->__curCallState, pCallInfo.get());
 390             SysTryReturnVoidResult(NID_TEL,pEventArg != null, E_OUT_OF_MEMORY,
 391                         "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 392
 393                 pCallInfo.release();
 394
 395                 SysLog(NID_TEL, "The current call type is %d, and the phonenumber is %ls", callType, phoneNumber.GetPointer());
 396             (void)pCallManagerImpl->__pCallManagerEvent->Fire(*pEventArg);
 397         }
 398 }
 399
 400 void
 401 _CallManagerImpl::OnTelephonyCallForwardNumberReceived(Tizen::Base::String phoneNumber, result r)
 402 {
 403         SysLog(NID_TEL, "The listener has called with result %s and phonenumber is %ls", GetErrorMessage(r), phoneNumber.GetPointer());
 404
 405     _CallForwardEventArg* pEventArg = new (std::nothrow)_CallForwardEventArg(_CALL_FORWARD_EVENT_NUMBER_RECEIVED, phoneNumber, r);
 406
 407     SysTryReturnVoidResult(NID_TEL,pEventArg != null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 408
 409     (void)__pCallForwardEvent->Fire(*pEventArg);
 410
 411     __isReqCallFwdNumInProgress = false;
 412 }
 413
 414 void
 415 _CallManagerImpl::OnTelephonyCallForwardResponseReceived(Tizen::Base::String phoneNumber, result r)
 416 {
 417         SysLog(NID_TEL, "The listener has called with result %s and phonenumber is %ls", GetErrorMessage(r), phoneNumber.GetPointer());
 418
 419     _CallForwardEventArg* pEventArg = new (std::nothrow)_CallForwardEventArg(_CALL_FORWARD_EVENT_RESPONSE_RECEIVED, phoneNumber, r);
 420
 421     SysTryReturnVoidResult(NID_TEL, pEventArg != null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 422
 423     (void)__pCallForwardEvent->Fire(*pEventArg);
 424
 425     if (r != E_SUCCESS)
 426     {
 427         __curCallFwdState = _CALL_FORWARD_IDLE;
 428     }
 429     else
 430     {
 431         __curCallFwdState = _CALL_FORWARD_ON_SERVICE;
 432     }
 433 }
 434
 435 void
 436 _CallManagerImpl::OnTelephonyCallForwardStopped(Tizen::Base::String phoneNumber, result r)
 437 {
 438     SysLog(NID_TEL, "The listener has called with result %s and phonenumber is %ls", GetErrorMessage(r), phoneNumber.GetPointer());
 439
 440     _CallForwardEventArg* pEventArg = new (std::nothrow)_CallForwardEventArg(_CALL_FORWARD_EVENT_STOPPED, phoneNumber, r);
 441
 442     SysTryReturnVoidResult(NID_TEL, pEventArg != null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 443
 444     (void)__pCallForwardEvent->Fire(*pEventArg);
 445
 446     if (r != E_SUCCESS)
 447     {
 448        __curCallFwdState = _CALL_FORWARD_ON_SERVICE;
 449     }
 450     else
 451     {
 452        __curCallFwdState = _CALL_FORWARD_IDLE;
 453     }
 454 }
 455
 456
 457 void
 458 _CallManagerImpl::OnCallStatusCallback(TelCallStatus_t* status, void* pUserData)
 459 {
 460         _CallManagerImpl* pImpl = static_cast<_CallManagerImpl*>(pUserData);
 461
 462         CallStatus tempCallStatus = CALL_STATUS_IDLE;
 463
 464         switch (status->CallState)
 465         {
 466         case TAPI_CALL_STATE_IDLE:
 467             tempCallStatus = CALL_STATUS_IDLE;
 468             break;
 469         case TAPI_CALL_STATE_ACTIVE:
 470                 tempCallStatus = CALL_STATUS_COMMUNICATING;
 471                 break;
 472         case TAPI_CALL_STATE_HELD:
 473             tempCallStatus = CALL_STATUS_HOLDING;
 474             break;
 475         case TAPI_CALL_STATE_INCOMING:
 476             tempCallStatus = CALL_STATUS_RINGING;
 477             break;
 478         case TAPI_CALL_STATE_DIALING:
 479         case TAPI_CALL_STATE_ALERT:
 480             tempCallStatus = CALL_STATUS_DIALING;
 481             break;
 482         default:
 483             break;
 484         }
 485
 486         if (tempCallStatus == CALL_STATUS_RINGING)
 487         {
 488                 pImpl->__curCallState = CALL_STATUS_RINGING;
 489         }
 490         else if ((tempCallStatus == CALL_STATUS_DIALING) && (pImpl->__curCallState != CALL_STATUS_RINGING))
 491         {
 492                 pImpl->__curCallState = CALL_STATUS_DIALING;
 493         }
 494         else if ((tempCallStatus == CALL_STATUS_COMMUNICATING) && (pImpl->__curCallState != CALL_STATUS_RINGING) && (pImpl->__curCallState != CALL_STATUS_DIALING))
 495         {
 496                 pImpl->__curCallState = CALL_STATUS_COMMUNICATING;
 497         }
 498         else if ((tempCallStatus == CALL_STATUS_HOLDING) && (pImpl->__curCallState != CALL_STATUS_RINGING) && (pImpl->__curCallState != CALL_STATUS_DIALING) && (pImpl->__curCallState != CALL_STATUS_COMMUNICATING))
 499         {
 500                 pImpl->__curCallState = CALL_STATUS_HOLDING;
 501         }
 502
 503         return;
 504 }
 505
 506 void
 507 _CallManagerImpl::OnCallTypeCallback(TelCallStatus_t* status, void* pUserData)
 508 {
 509         CallType* pCallType = static_cast<CallType*>(pUserData);
 510
 511         switch (status->CallType)
 512         {
 513         case TAPI_CALL_TYPE_VOICE:
 514             *pCallType = TYPE_VOICE_CALL;
 515             break;
 516         case TAPI_CALL_TYPE_DATA:
 517             *pCallType = TYPE_VIDEO_CALL;
 518             break;
 519         default:
 520             break;
 521         }
 522
 523         return;
 524 }
 525
 526 bool
 527 _CallManagerImpl::IsPhoneNumberValid(const String& phoneNumber) const
 528 {
 529         bool isValid = true;
 530         int startIndex = 0;
 531         wchar_t chr = 0;
 532
 533         if (phoneNumber.StartsWith("+", 0))
 534         {
 535                 startIndex = 1;
 536         }
 537
 538         for (int i = startIndex; i < phoneNumber.GetLength(); i++)
 539         {
 540                 phoneNumber.GetCharAt(i, chr);
 541
 542                 if (!Character::IsDigit(chr))
 543                 {
 544                         isValid = false;
 545                         break;
 546                 }
 547         }
 548         return isValid;
 549 }
 550
 551 result
 552 _CallManagerImpl::InitializeInternalCallStatus(void)
 553 {
 554         int err = TAPI_API_SUCCESS;
 555         result r = E_SUCCESS;
 556
 557         __curCallState = CALL_STATUS_IDLE;
 558         err = tel_get_call_status_all(__pHandle, OnCallStatusCallback, this);
 559         SysLog(NID_TEL, "The tel_get_call_status_all() returned %d value", err);
 560
 561         if (err != TAPI_API_SUCCESS)
 562         {
 563             if (err == TAPI_API_OPERATION_FAILED)
 564             {
 565                 __curCallState = CALL_STATUS_IDLE;
 566             }
 567             else
 568             {
 569                 r = E_SYSTEM;
 570             }
 571         }
 572
 573         return r;
 574 }
 575
 576 String
 577 _CallManagerImpl::GetPhoneNumber(TapiHandle* pCallHandle, int callId) const
 578 {
 579         int err = TAPI_API_SUCCESS;
 580         String phoneNumber;
 581
 582         TelCallStatus_t callStatus = {};
 583         err = tel_get_call_status(pCallHandle, callId, &callStatus);
 584         if (err == TAPI_API_SUCCESS)
 585         {
 586             (void)(StringUtil::Utf8ToString(callStatus.pNumber, phoneNumber));
 587             SysLog(NID_TEL, "The phone number is %ls", phoneNumber.GetPointer());
 588         }
 589         else
 590         {
 591             SysLog(NID_TEL, "The tel_get_call_status_all() returned %d value", err);
 592         }
 593
 594         return phoneNumber;
 595 }
 596
 597 const char*
 598 _CallManagerImpl::GetStringOfCallState(void) const
 599 {
 600         static const char* pStateStr[] =
 601         {
 602                 "CALL_STATUS_UNDEFINED",
 603                 "CALL_STATUS_IDLE",
 604                 "CALL_STATUS_ACTIVE",
 605                 "CALL_STATUS_COMMUNICATING",
 606                 "CALL_STATUS_RINGING",
 607                 "CALL_STATUS_DIALING",
 608                 "CALL_STATUS_HOLDING"
 609         };
 610
 611         return pStateStr[__curCallState + 1];
 612 }
 613
 614 const char*
 615 _CallManagerImpl::GetStringOfCallFwdState(void) const
 616 {
 617         static const char* pFwdStateStr[] =
 618         {
 619                 "CALL_FORWARD_IDLE",
 620                 "CALL_FORWARD_REQUESTING",
 621                 "CALL_FORWARD_ON_SERVICE",
 622                 "CALL_FORWARD_STOPPING"
 623         };
 624
 625         return pFwdStateStr[__curCallFwdState];
 626 }
 627
 628 const char*
 629 _CallManagerImpl::GetStringOfCallEventType(int type) const
 630 {
 631         static const char* pEventType[] =
 632         {
 633                 "Voice Call End",
 634                 "Voice Communicating",
 635                 "Voice Ringing",
 636                 "Voice Dialing",
 637                 "Voice Holding",
 638                 "Video Call End",
 639                 "Video Communicating",
 640                 "Video Ringing",
 641                 "Video Dialing",
 642                 "Peer Held",
 643                 "Peer Retrieved"
 644         };
 645
 646         return pEventType[type];
 647 }
 648
 649 _CallManagerImpl*
 650 _CallManagerImpl::GetInstance(CallManager& callManager)
 651 {
 652         return callManager.__pCallManagerImpl;
 653 }
 654
 655 const _CallManagerImpl*
 656 _CallManagerImpl::GetInstance(const CallManager& callManager)
 657 {
 658         return callManager.__pCallManagerImpl;
 659 }
 660
 661 }} // Tizen::Telephony
 662
 663