, public Tizen::Base::Runtime::ITimerEventListener
, public Tizen::Ui::IOrientationEventListener
, public Tizen::Social::IAddressbookChangeEventListener
+ , public Tizen::Ui::IPropagatedKeyEventListener
{
public:
ActiveCallForm(FormType formType);
//From BaseForm
virtual void Initialize(void);
void SetSwapInProgress(bool progress);
+ void SetCallStateInProgress(bool progress);
+ void SetConfCallStateInProgress(bool progress);
+ void OnHoldTelephonyCallback(bool isHeld);
+ void OnActiveTelephonyCallback(bool isActive);
+ void OnConfCallHoldTelephonyCallback(bool isHeld);
+ void OnConfCallActiveTelephonyCallback(bool isActive);
+
public:
virtual result OnInitializing(void);
void HandleConfCallChanged(void);
// Used to update multiple call screen
void UpdateMultipleCallScreen(Tizen::Base::Collection::IListT<AppCallInfo>& activeCallsList);
+ //Handle hold conference call
//IAddressbookChangeEventListener
virtual void OnContactsChanged(const Tizen::Base::Collection::IList& contactChangeInfoList);
virtual void OnCategoriesChanged(const Tizen::Base::Collection::IList& categoryChangeInfoList);
virtual void OnListViewItemSwept(Tizen::Ui::Controls::ListView& listView, int index, Tizen::Ui::Controls::SweepDirection direction);
virtual void OnListViewItemLongPressed(Tizen::Ui::Controls::ListView& listView, int index, int elementId, bool& invokeListViewItemCallback);
+ //IPropagatedKeyEventListener
+ virtual bool OnKeyPressed(Control& source, const Tizen::Ui::KeyEventInfo& keyEventInfo);
+ virtual bool OnKeyReleased(Control& source, const Tizen::Ui::KeyEventInfo& keyEventInfo){ return false; };
+ virtual bool OnPreviewKeyPressed(Control& source, const Tizen::Ui::KeyEventInfo& keyEventInfo){ return false; }
+ virtual bool OnPreviewKeyReleased(Control& source, const Tizen::Ui::KeyEventInfo& keyEventInfo){ return false; }
+ virtual bool TranslateKeyEventInfo(Control& source, Tizen::Ui::KeyEventInfo& keyEventInfo) { return false; }
+
//From IListViewItemProvider
virtual Tizen::Ui::Controls::ListItemBase* CreateItem(int index, int itemWidth);
virtual bool DeleteItem(int index, Tizen::Ui::Controls::ListItemBase* pItem, int itemWidth);
void ShowThumbnailImage(const Tizen::Graphics::Bitmap* pPhotoId,Tizen::Base::String& photoLabel);
//Check if swap in progress
bool IsSwapInProgress(void);
+ bool IsCallStateInProgress(void);
+ bool IsConfCallStateInProgress(void);
private:
//Start time for Active call
AppCallInfo* __pActiveCallInfo;
AppCallInfo* __pHeldCallInfo;
bool __isSwapInProgress;
+ bool __isCallStateInProgress;
+ bool __isConfCallStateInProgress;
};
#endif //_PHN_ACTIVE_CALL_FORM_H_
//Event Listener methods from ITelephonyEventListener
virtual void HandleCallConnected(Tizen::Base::Collection::IListT<AppCallInfo>& pCallList);
virtual void HandleCallDisconnected(bool isLastCall, Tizen::Base::Collection::IListT<AppCallInfo>& pCallList);
+ virtual void HandleCallHeld(bool isHeld);
+ virtual void HandleCallActive(bool isActive);
virtual void HandleConferenceCall(AppCallInfo& pCallInfo);
virtual void HandleIncomingCall(AppCallInfo& pCallInfo);
+ virtual void HandleConfCallHoldOccured(bool success);
+ virtual void HandleConfCallActiveOccured(bool success);
virtual void HandleCallSwapOccured(Tizen::Base::Collection::IListT<AppCallInfo>& pCallList);
virtual void HandleConferenceChange(void);
virtual void HandleTelephonyError(int errorCode);
//Disable all the elements
void DisableAllControls(void);
- //
+ void OnConfCallHoldTelephoneCallBackOccured(bool success);
+ void OnConfCallActiveTelephoneCallBackOccured(bool success);
+ bool IsConfCallStateInProgress(void);
+ void SetConfCallStateInProgress(bool progress);
// From 'Container'.
// Called when the container needs to draw itself. @n
// Users can override this method to display user-specific drawings. @n
Tizen::Social::Addressbook* __pAddressbook;
Tizen::Ui::Controls::TableView* __pList;
bool __isCallSplit;
+ bool __isConfCallStateInProgress;
};
#endif //_PHN_CONF_CALLER_LIST_FORM_H_
virtual void HandleCallDisconnected(bool isLastCall, Tizen::Base::Collection::IListT<AppCallInfo>& pCallList) = 0;
/**
+ * This function is called when a call is held. It returns the list of active calls
+ *
+ * @param[out] isHeld - true for currently held call
+ */
+ virtual void HandleCallHeld(bool isHeld) = 0;
+ /**
+ * This function is called when a call is active. It returns the list of active calls
+ *
+ * @param[out] isActive - true for currently active call
+ */
+ virtual void HandleCallActive(bool isActive) = 0;
+ /**
* This function is called when two calls are joined and a conference call is setup.
*
* @param[in] pCallInfo - The conference call information data.
*/
virtual void HandleCallSwapOccured(Tizen::Base::Collection::IListT<AppCallInfo>& pCallList) = 0;
+ /*
+ * Called when the conference call is held.
+ * Implement this to handle voice call events.
+ * @param[out] success - If true then the conference call is successfully held else not.
+ */
+ virtual void HandleConfCallHoldOccured(bool success) = 0;
+
+ /*
+ * Called when the conference call is active.
+ * Implement this to handle voice call events.
+ * @param[out] success - If true then the conference call is successfully active
+ */
+ virtual void HandleConfCallActiveOccured(bool success) = 0;
+
/**
* Called when the conference list changes.
* Implement this to handle voice call events.
virtual void HandleConferenceCall(AppCallInfo& pCallInfo);
virtual void HandleIncomingCall(AppCallInfo& pCallInfo);
virtual void HandleCallSwapOccured(Tizen::Base::Collection::IListT<AppCallInfo>& pCallList);
+ virtual void HandleConfCallHoldOccured(bool success);
+ virtual void HandleConfCallActiveOccured(bool success);
virtual void HandleConferenceChange(void);
virtual void HandleTelephonyError(int errorCode);
+ virtual void HandleCallHeld(bool isHeld);
+ virtual void HandleCallActive(bool isActive);
//From IAppControlResponseListener
virtual void OnAppControlCompleteResponseReceived(const Tizen::App::AppId& appId, const Tizen::Base::String& operationId, Tizen::App::AppCtrlResult appControlResult, const Tizen::Base::Collection::IMap* pExtraData);
virtual void OnAppForeground(void);
static void HandleCallbackResponse(TapiHandle* pHandle, int callBackResult, void* pData, void* pUserData);
//Hold Callback
static void HandleHoldCallbackResponse(TapiHandle* pHandle, int callBackResult, void* pData, void* pUserData);
+ //Active Callback
+ static void HandleActiveCallbackResponse(TapiHandle* pHandle, int callBackResult, void* pData, void* pUserData);
+ //Hold Conference CallBack
+ static void HandleHoldConferenceCallbackResponse(TapiHandle* pHandle, int callBackResult, void* pData, void* pUserData);
+ //Active Conference CallBack
+ static void HandleActiveConferenceCallbackResponse(TapiHandle* pHandle, int callBackResult, void* pData, void* pUserData);
//callback function for dial operation
static void HandleDialCallbackResponse(TapiHandle* pHandle, int callBackResult, void* pData, void* pUserData);
//callback function for the join operation
__pActiveCallInfo = null;
__pHeldCallInfo = null;
__isSwapInProgress = false;
+ __isCallStateInProgress = false;
+ __isConfCallStateInProgress = false;
__pAddressbook = null;
}
__pDTMFKeypad->SetShowState(true);
__pDTMFKeypad->Draw(true);
__pDTMFKeypad->Show();
+ pTextBox->SetPropagatedKeyEventListener(this);
pTextBox->SetFocus();
}
{
if(__pDTMFKeypad != null)
{
- __DtmfString = static_cast<EditField*>(__pDTMFKeypad->GetControl(IDC_TEXTBOX))->GetText();
+ EditField* pTextBox = static_cast<EditField*>(__pDTMFKeypad->GetControl(IDC_TEXTBOX));
+ __DtmfString = pTextBox->GetText();
__pDTMFKeypad->SetShowState(false);
+ pTextBox->SetPropagatedKeyEventListener(null);
}
}
if (__pMoreOptionsListAnchor != null)
{
//removes and delete the child control
- RemoveControl(__pMoreOptionsListAnchor);
+ //Commented this for the bug N_SE-52426 and added SetShowState(false) below
+ //RemoveControl(__pMoreOptionsListAnchor);
+ __pMoreOptionsListAnchor->SetShowState(false);
__pMoreOptionsListAnchor = null;
}
if (__pMoreOptionsList != null)
{
//removes and delete the child control
- RemoveControl(__pMoreOptionsList);
+ //Commented this for the bug N_SE-52426 and added SetShowState(false) below
+ //RemoveControl(__pMoreOptionsList);
+ __pMoreOptionsList->SetShowState(false);
__pMoreOptionsList = null;
}
}
{
if(__pActiveCallInfo->GetCallHandle() != null)
{
- success = __pCallPresentor->HoldCall(*__pActiveCallInfo->GetCallHandle());
+ if(IsCallStateInProgress() == false)
+ {
+ success = __pCallPresentor->HoldCall(*__pActiveCallInfo->GetCallHandle());
+ SetCallStateInProgress(true);
+ }
}
}
else
{
success = __pCallPresentor->HoldConferenceCall();
}
- //reset hold status and "OnHold" text
- ShowTimerInfo(IDC_CALLER1_TIME_LABEL, success);
- if(__pActiveCallTimer != null)
- {
- __pActiveCallTimer->Cancel();
- }
- SetHoldButtonStatus(!success);
}
break;
{
if(__pActiveCallInfo->GetCallHandle() != null)
{
- success = __pCallPresentor->UnHoldCall(*__pActiveCallInfo->GetCallHandle());
+ if(IsCallStateInProgress() == false)
+ {
+ success = __pCallPresentor->UnHoldCall(*__pActiveCallInfo->GetCallHandle());
+ SetCallStateInProgress(true);
+ }
}
}
else
{
success = __pCallPresentor->ActivateConferenceCall();
}
- //reset hold status and show call timer
- ShowTimerInfo(IDC_CALLER1_TIME_LABEL, !success, __activeCallStartTime);
- SetHoldButtonStatus(success);
}
break;
case IDA_HOLD_CONF_CALL:
{
AppAssert(__formType == FORMTYPE_ACTIVECONFCALL);
- bool success = __pCallPresentor->HoldConferenceCall();
- //reset hold status and "OnHold" text
- SetHoldButtonStatus(!success);
- ShowTimerInfo(IDC_CALLER1_TIME_LABEL, success);
- if(__pActiveCallTimer != null)
+ if(IsConfCallStateInProgress() == false)
{
- __pActiveCallTimer->Cancel();
+ bool success = __pCallPresentor->HoldConferenceCall();
+ SetConfCallStateInProgress(true);
}
}
break;
case IDA_UNHOLD_CONF_CALL:
{
AppAssert(__formType == FORMTYPE_ACTIVECONFCALL);
- bool success = __pCallPresentor->ActivateConferenceCall();
- //reset hold status and show call timer
- ShowTimerInfo(IDC_CALLER1_TIME_LABEL, !success, __activeCallStartTime);
- SetHoldButtonStatus(success);
+ if(IsConfCallStateInProgress() == false)
+ {
+ bool success = __pCallPresentor->ActivateConferenceCall();
+ SetConfCallStateInProgress(true);
+ }
}
break;
}
bool
+ActiveCallForm::IsConfCallStateInProgress(void)
+{
+ return __isConfCallStateInProgress;
+}
+
+
+bool
+ActiveCallForm::IsCallStateInProgress(void)
+{
+ return __isCallStateInProgress;
+}
+
+bool
ActiveCallForm::IsSwapInProgress(void)
{
return __isSwapInProgress;
}
+
+void
+ActiveCallForm::OnActiveTelephonyCallback(bool isActive)
+{
+ AppLogDebug("Enter");
+ //reset hold status and show call timer
+ ShowTimerInfo(IDC_CALLER1_TIME_LABEL, !isActive, __activeCallStartTime);
+ SetHoldButtonStatus(isActive);
+ SetCallStateInProgress(false);
+}
+
+void
+ActiveCallForm::OnHoldTelephonyCallback(bool isHeld)
+{
+ AppLogDebug("Enter");
+ //reset hold status and "OnHold" text
+ ShowTimerInfo(IDC_CALLER1_TIME_LABEL, isHeld);
+ if(__pActiveCallTimer != null)
+ {
+ __pActiveCallTimer->Cancel();
+ }
+ SetHoldButtonStatus(!isHeld);
+ SetCallStateInProgress(false);
+}
+
+void
+ActiveCallForm::SetConfCallStateInProgress(bool progress)
+{
+ __isConfCallStateInProgress = progress;
+}
+
+void
+ActiveCallForm::SetCallStateInProgress(bool progress)
+{
+ __isCallStateInProgress = progress;
+}
+
void
ActiveCallForm::SetSwapInProgress(bool progress)
{
//No implementation
}
+void
+ActiveCallForm::OnConfCallHoldTelephonyCallback(bool isHeld)
+{
+ //reset hold status and "OnHold" text
+ SetHoldButtonStatus(!isHeld);
+ ShowTimerInfo(IDC_CALLER1_TIME_LABEL, isHeld);
+ if(__pActiveCallTimer != null)
+ {
+ __pActiveCallTimer->Cancel();
+ }
+ SetConfCallStateInProgress(false);
+}
+
+void
+ActiveCallForm::OnConfCallActiveTelephonyCallback(bool isActive)
+{
+ //reset hold status and show call timer
+ ShowTimerInfo(IDC_CALLER1_TIME_LABEL, !isActive, __activeCallStartTime);
+ SetHoldButtonStatus(isActive);
+ SetConfCallStateInProgress(false);
+}
+
void
ActiveCallForm::UpdateMultipleCallScreen(Tizen::Base::Collection::IListT<AppCallInfo>& activeCallsList)
AppLogDebug("Enter");
__pCallPresentor->OnAppForeground();
}
+
+bool
+ActiveCallForm::OnKeyPressed(Control& source, const KeyEventInfo& keyEventInfo)
+{
+ AppLogDebug("Enter");
+
+ if(keyEventInfo.GetKeyCode() == KEY_BACKSPACE || keyEventInfo.GetKeyCode() == KEY_DELETE)
+ {
+ if(__pDTMFKeypad != null)
+ {
+ EditField* pTextBox = static_cast<EditField*>(__pDTMFKeypad->GetControl(IDC_TEXTBOX));
+ if(source.Equals(*pTextBox))
+ {
+ AppLogDebug("Enter");
+ return true;
+ }
+ }
+ }
+
+ return false;
+}
{
//single Conference call - goto active Conf. call form
pSceneManager->GoForward(ForwardSceneTransition(IDSCN_SCENE_CONFCALL,
- SCENE_TRANSITION_ANIMATION_TYPE_NONE, SCENE_HISTORY_OPTION_NO_HISTORY,SCENE_DESTROY_OPTION_KEEP), pCallInfoList);
+ SCENE_TRANSITION_ANIMATION_TYPE_NONE, SCENE_HISTORY_OPTION_NO_HISTORY,SCENE_DESTROY_OPTION_DESTROY), pCallInfoList);
}
else
{
//single active call - goto active call form
pSceneManager->GoForward(ForwardSceneTransition(IDSCN_SCENE_ACTIVECALL,
- SCENE_TRANSITION_ANIMATION_TYPE_NONE, SCENE_HISTORY_OPTION_NO_HISTORY,SCENE_DESTROY_OPTION_KEEP), pCallInfoList);
+ SCENE_TRANSITION_ANIMATION_TYPE_NONE, SCENE_HISTORY_OPTION_NO_HISTORY,SCENE_DESTROY_OPTION_DESTROY), pCallInfoList);
}
}
else if(noOfCalls == 2)
}
void
+BaseForm::HandleCallActive(bool isActive)
+{
+ AppLogDebug("Enter");
+ ActiveCallForm* pActiveCallForm = dynamic_cast<ActiveCallForm*>(this);
+ if(pActiveCallForm != null)
+ {
+ pActiveCallForm->OnActiveTelephonyCallback(isActive);
+ }
+}
+
+void
+BaseForm::HandleCallHeld(bool isHeld)
+{
+ AppLogDebug("Enter");
+ ActiveCallForm* pActiveCallForm = dynamic_cast<ActiveCallForm*>(this);
+ if(pActiveCallForm != null)
+ {
+ pActiveCallForm->OnHoldTelephonyCallback(isHeld);
+ }
+}
+
+void
BaseForm::HandleCallDisconnected(bool isLastCall, IListT<AppCallInfo>& pCurrentActiveCallList)
{
AppLogDebug("Enter");
}
void
+BaseForm::HandleConfCallHoldOccured(bool success)
+{
+
+ switch (__formType)
+ {
+ case FORMTYPE_CONFCALLLIST:
+ {
+ ConfCallerListForm* pConfCallerListForm = dynamic_cast<ConfCallerListForm*>(this);
+ if(pConfCallerListForm != null)
+ {
+ pConfCallerListForm->OnConfCallHoldTelephoneCallBackOccured(success);
+ }
+ }
+ break;
+ case FORMTYPE_ACTIVECONFCALL:
+ {
+ ActiveCallForm* pActiveCallForm = dynamic_cast<ActiveCallForm*>(this);
+ if(pActiveCallForm != null)
+ {
+ pActiveCallForm->OnConfCallHoldTelephonyCallback(success);
+ }
+ }
+ break;
+ default:
+ break;
+ }
+}
+
+void
+BaseForm::HandleConfCallActiveOccured(bool success)
+{
+ switch (__formType)
+ {
+ case FORMTYPE_CONFCALLLIST:
+ {
+ ConfCallerListForm* pConfCallerListForm = dynamic_cast<ConfCallerListForm*>(this);
+ if(pConfCallerListForm != null)
+ {
+ pConfCallerListForm->OnConfCallActiveTelephoneCallBackOccured(success);
+ }
+ }
+ break;
+ case FORMTYPE_ACTIVECONFCALL:
+ {
+ ActiveCallForm* pActiveCallForm = dynamic_cast<ActiveCallForm*>(this);
+ if(pActiveCallForm != null)
+ {
+ pActiveCallForm->OnConfCallActiveTelephonyCallback(success);
+ }
+ }
+ break;
+ default:
+ break;
+ }
+}
+
+void
BaseForm::HandleCallSwapOccured(IListT<AppCallInfo>& pCallList)
{
int noOfCalls = pCallList.GetCount();
__pConfCallInfo = null;
__pConfCallTimer = null;
__isCallSplit = false;
+ __isConfCallStateInProgress = false;
__pAddressbook = null;
}
}
bool success = true;
bool isCallOnHold = __pConfCallInfo->IsOnHold();
- if (isCallOnHold == false)
+ if(IsConfCallStateInProgress() == false)
{
- success = __pCallPresentor->HoldConferenceCall();
- }
- else
- {
- success = __pCallPresentor->ActivateConferenceCall();
- }
-
- //Check if request to Hold / UnHold call is successful.
- if(success == true)
- {
- //If success, then invert the Hold status in conference call
- isCallOnHold = !(isCallOnHold);
- __pConfCallInfo->SetOnHold(isCallOnHold);
- //update tableview
- __pList->UpdateTableView();
- SetHoldButtonStatus(isCallOnHold);
+ if (isCallOnHold == false)
+ {
+ success = __pCallPresentor->HoldConferenceCall();
+ SetConfCallStateInProgress(true);
+ }
+ else
+ {
+ success = __pCallPresentor->ActivateConferenceCall();
+ SetConfCallStateInProgress(true);
+ }
}
}
break;
__pList->SetEnabled(true);
}
+
+void
+ConfCallerListForm::OnConfCallHoldTelephoneCallBackOccured(bool success)
+{
+ bool isCallOnHold = __pConfCallInfo->IsOnHold();
+ isCallOnHold = !(isCallOnHold);
+ __pConfCallInfo->SetOnHold(isCallOnHold);
+ __pList->UpdateTableView();
+ SetHoldButtonStatus(isCallOnHold);
+ SetConfCallStateInProgress(false);
+
+}
+
+bool
+ConfCallerListForm::IsConfCallStateInProgress(void)
+{
+ return __isConfCallStateInProgress;
+}
+
+void
+ConfCallerListForm::SetConfCallStateInProgress(bool progress)
+{
+ __isConfCallStateInProgress = progress;
+}
+
+
+void
+ConfCallerListForm::OnConfCallActiveTelephoneCallBackOccured(bool success)
+{
+ bool isCallOnHold = __pConfCallInfo->IsOnHold();
+ isCallOnHold = !(isCallOnHold);
+ __pConfCallInfo->SetOnHold(!success);
+ __pList->UpdateTableView();
+ SetHoldButtonStatus(!success);
+ SetConfCallStateInProgress(false);
+
+}
+
+/*void
+ConfCallerListForm::HandleHoldConferenceCallback(bool success)
+{
+ if(success == true)
+ {
+ __pList->UpdateTableView();
+ SetHoldButtonStatus(success);
+ }
+}*/
+
void
ConfCallerListForm::DisableAllControls(void)
{
//This is done so that when in IncomingCallForm and calloptionpopup is shown , now if
// focus goes away from popup by pressing cancel key from the host keyboard the focus shouldnt get lost
// but should focus the Reject message button immediately.
- Button* pButtonRejectMessage = static_cast<Button*>(GetControl(IDC_REJECT_MESSAGE_BUTTON));
- pButtonRejectMessage->SetFocus();
- pButtonRejectMessage->Invalidate(true);
+// Button* pButtonRejectMessage = static_cast<Button*>(GetControl(IDC_REJECT_MESSAGE_BUTTON));
+//Commented for bug N_SE-52277
+ //pButtonRejectMessage->SetFocus();
+ //pButtonRejectMessage->Invalidate(true);
__pCallPresentor->OnAppForeground();
}
}
void
+CallPresentationModel::HandleCallActive(bool isActive)
+{
+ if (__pTelEventListener != null)
+ {
+ __pTelEventListener->HandleCallActive(isActive);
+ }
+}
+
+void
+CallPresentationModel::HandleCallHeld(bool isHeld)
+{
+ if (__pTelEventListener != null)
+ {
+ __pTelEventListener->HandleCallHeld(isHeld);
+ }
+}
+
+void
CallPresentationModel::HandleCallDisconnected(bool isLastCall, Tizen::Base::Collection::IListT<AppCallInfo>& pCallList)
{
AppLogDebug("Enter");
}
void
+CallPresentationModel::HandleConfCallHoldOccured(bool success)
+{
+ if (__pTelEventListener != null)
+ {
+ __pTelEventListener->HandleConfCallHoldOccured(success);
+ }
+}
+
+void
+CallPresentationModel::HandleConfCallActiveOccured(bool success)
+{
+ if (__pTelEventListener != null)
+ {
+ __pTelEventListener->HandleConfCallActiveOccured(success);
+ }
+}
+
+void
CallPresentationModel::HandleCallSwapOccured(Tizen::Base::Collection::IListT<AppCallInfo>& pCallList)
{
if (__pTelEventListener != null)
int res = TAPI_API_INVALID_INPUT;
if (holdCall == true)
{
- res = tel_hold_call(__pTapiHandle, callHandle, &HandleCallbackResponse, this);
+ res = tel_hold_call(__pTapiHandle, callHandle, &HandleHoldConferenceCallbackResponse, this);
}
else
{
- res = tel_active_call(__pTapiHandle, callHandle, &HandleCallbackResponse, this);
+ res = tel_active_call(__pTapiHandle, callHandle, &HandleActiveConferenceCallbackResponse, this);
}
- if (res == TAPI_API_SUCCESS)
+
+ if (res == TAPI_CAUSE_SUCCESS)
{
r = E_SUCCESS;
- if (holdCall == true)
- {
- confCallToHold.SetOnHold(true);
- }
- else
- {
- confCallToHold.SetOnHold(false);
- }
- AppCallInfo* pConfCallInfo = new (std::nothrow) AppCallInfo();
- *pConfCallInfo = confCallToHold;
- __pActiveCallList->Remove(callHandle);
- __pActiveCallList->Add(callHandle, *pConfCallInfo);
}
else
{
}
else
{
- retStatus = tel_active_call(__pTapiHandle, callHandle, &HandleCallbackResponse, this);
+ retStatus = tel_active_call(__pTapiHandle, callHandle, &HandleActiveCallbackResponse, this);
}
if (retStatus == TAPI_CAUSE_SUCCESS)
{
- AppCallInfo* pHeldCallInfo = new (std::nothrow) AppCallInfo();
- //copy state into new callinfo object
- *pHeldCallInfo = *pActiveCallInfo;
-
- //set call to hold state
- pHeldCallInfo->SetOnHold(holdCall);
-
- __pActiveCallList->Remove(callHandle);
- //replace old object with new
- __pActiveCallList->Add(callHandle, *pHeldCallInfo);
return E_SUCCESS;
}
else
return false;
}
void
+TelephonyManager::HandleActiveConferenceCallbackResponse(TapiHandle* pHandle, int callBackResult, void* pData, void* pUserData)
+{
+ TelephonyManager* pTelManager = (TelephonyManager*) pUserData;
+ AppCallInfo confCallToHold;
+ IListT<AppCallInfo>* pCallList = pTelManager->__pActiveCallList->GetValuesN();
+ int confCallCount = pCallList->GetCount();
+
+ for (int index = 0; index < confCallCount; index++)
+ {
+ pCallList->GetAt(index, confCallToHold);
+ if (confCallToHold.IsConferenceCall() == true)
+ {
+ unsigned int conferenceCallHandleToHold = 0;
+ memcpy(&conferenceCallHandleToHold, pData, sizeof(TS_UINT));
+ if (callBackResult == TAPI_API_SUCCESS)
+ {
+ confCallToHold.SetOnHold(false);
+ AppCallInfo* pConfCallInfo = new (std::nothrow) AppCallInfo();
+ *pConfCallInfo = confCallToHold;
+ pTelManager->__pActiveCallList->Remove(conferenceCallHandleToHold);
+ pTelManager->__pActiveCallList->Add(conferenceCallHandleToHold, *pConfCallInfo);
+ pTelManager->__pEventListener->HandleConfCallActiveOccured(true);
+ }
+ break;
+ }
+ }
+
+ if(pCallList != null)
+ {
+ delete pCallList;
+ pCallList = null;
+ }
+}
+void
+TelephonyManager::HandleHoldConferenceCallbackResponse(TapiHandle* pHandle, int callBackResult, void* pData, void* pUserData)
+{
+ TelephonyManager* pTelManager = (TelephonyManager*) pUserData;
+ AppCallInfo confCallToHold;
+ bool isConferenceCallFound = false;
+ IListT<AppCallInfo>* pCallList = pTelManager->__pActiveCallList->GetValuesN();
+ int confCallCount = pCallList->GetCount();
+
+ for (int index = 0; index < confCallCount; index++)
+ {
+ pCallList->GetAt(index, confCallToHold);
+ if (confCallToHold.IsConferenceCall() == true)
+ {
+ unsigned int conferenceCallHandleToHold = 0;
+ memcpy(&conferenceCallHandleToHold, pData, sizeof(TS_UINT));
+ if (callBackResult == TAPI_API_SUCCESS)
+ {
+ confCallToHold.SetOnHold(true);
+ AppCallInfo* pConfCallInfo = new (std::nothrow) AppCallInfo();
+ *pConfCallInfo = confCallToHold;
+ pTelManager->__pActiveCallList->Remove(conferenceCallHandleToHold);
+ pTelManager->__pActiveCallList->Add(conferenceCallHandleToHold, *pConfCallInfo);
+ pTelManager->__pEventListener->HandleConfCallHoldOccured(true);
+ }
+ break;
+ }
+ }
+ if(pCallList != null)
+ {
+ delete pCallList;
+ pCallList = null;
+ }
+}
+
+
+void
TelephonyManager::HandleHoldCallbackResponse(TapiHandle* pHandle, int callBackResult, void* pData, void* pUserData)
{
AppLogDebug("%d",callBackResult);
+ result r = E_FAILURE;
TelephonyManager* pTelManager = (TelephonyManager*) pUserData;
+ if (pData != null && callBackResult == TAPI_API_SUCCESS)
+ {
+ unsigned int heldCallHandle = 0;
+ memcpy(&heldCallHandle, pData, sizeof(TS_UINT));
+
+ if (pTelManager->__pActiveCallList->GetCount())
+ {
+ IListT<AppCallInfo>* pCallList = pTelManager->__pActiveCallList->GetValuesN();
+ int callCount = pCallList->GetCount();
+ for (int index = 0; index < callCount; index++)
+ {
+ AppCallInfo holdCallInfo;
+ r = pCallList->GetAt(index, holdCallInfo);
+ //check if an active call is found with matching contact no.
+ if ((r == E_SUCCESS) && (heldCallHandle == (unsigned int) holdCallInfo.GetCallHandle()->ToLong()))
+ {
+ AppCallInfo* pHeldCallInfo = new (std::nothrow) AppCallInfo();
+ //copy state into new callinfo object
+ *pHeldCallInfo = holdCallInfo;
+ //set call to hold state
+ pHeldCallInfo->SetOnHold(true);
+ //update the state of the call in Active call list by removing and adding again
+ pTelManager->__pActiveCallList->Remove(heldCallHandle);
+ pTelManager->__pActiveCallList->Add(heldCallHandle, *pHeldCallInfo);
+ pTelManager->__pEventListener->HandleCallHeld(true);
+ break;
+ }
+ }
+ delete pCallList;
+ pCallList = null;
+ }
+ }
pTelManager->CheckPendingDialCalls(callBackResult);
}
+
+void
+TelephonyManager::HandleActiveCallbackResponse(TapiHandle* pHandle, int callBackResult, void* pData, void* pUserData)
+{
+ AppLogDebug("%d",callBackResult);
+ result r = E_FAILURE;
+ TelephonyManager* pTelManager = (TelephonyManager*) pUserData;
+ if (pData != null && callBackResult == TAPI_API_SUCCESS)
+ {
+ unsigned int activeCallHandle = 0;
+ memcpy(&activeCallHandle, pData, sizeof(TS_UINT));
+
+ if (pTelManager->__pActiveCallList->GetCount())
+ {
+ IListT<AppCallInfo>* pCallList = pTelManager->__pActiveCallList->GetValuesN();
+ int callCount = pCallList->GetCount();
+ for (int index = 0; index < callCount; index++)
+ {
+ AppCallInfo ActiveCallInfo;
+ r = pCallList->GetAt(index, ActiveCallInfo);
+ //check if an active call is found with matching contact no.
+ if ((r == E_SUCCESS) && (activeCallHandle == (unsigned int) ActiveCallInfo.GetCallHandle()->ToLong()))
+ {
+ AppCallInfo* pActiveCallInfo = new (std::nothrow) AppCallInfo();
+ //copy state into new callinfo object
+ *pActiveCallInfo = ActiveCallInfo;
+ //set call to active state
+ pActiveCallInfo->SetOnHold(false);
+ //update the state of the call in Active call list by removing and adding again
+ pTelManager->__pActiveCallList->Remove(activeCallHandle);
+ pTelManager->__pActiveCallList->Add(activeCallHandle, *pActiveCallInfo);
+ break;
+ }
+ }
+ delete pCallList;
+ pCallList = null;
+ pTelManager->__pEventListener->HandleCallActive(true);
+ }
+ }
+}
+
void
TelephonyManager::HandleCallbackResponse(TapiHandle* pHandle, int callBackResult, void* pData, void* pUserData)
{
projects / apps / osp / Call.git / commitdiff