// Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// CLtsyCallControlHandler

//system include

#include <ctsy/ltsy/cctsydispatchercallback.h>

#include <mmtsy_ipcdefs.h>

#include <ctsy/ltsy/ltsylogger.h>

//#include <e32des16.h> 

#include <e32base.h>

#include <e32std.h>

#include <e32cons.h>

//user include

#include "cltsycallcontrolhandler.h"

#include "globalphonemanager.h"

#include "ltsycommondefine.h"

#include "mslogger.h"

#include "ltsymacros.h"

#include "tsyconfg.h"

#include "atwaitforcallhandler.h"

#include "atdialvoice.h"

#include "athangup.h"

#include "atanswer.h"

#include "atchld.h"

#include "unsolicitedcommandcallcontrolhandler.h"

#include "atdtmfvts.h"

#include "ltsycallinformationmanager.h"

#include "athangupcommandrecords.h"

//const define

_LIT16(KLtsyEmergencyCallNumber911, "911");

_LIT16(KLtsyEmergencyCallNumber112, "112");

CLtsyCallControlHandler::CLtsyCallControlHandler(

	CCtsyDispatcherCallback& aCtsyDispatcherCallback, CGlobalPhonemanager* aGloblePhone)

	: iCtsyDispatcherCallback(aCtsyDispatcherCallback), iGloblePhone(aGloblePhone)

	{

	}

CLtsyCallControlHandler::~CLtsyCallControlHandler()

	{

	delete iEmergencyCall;

	iEmergencyCall = NULL;

	delete iUnsolicitedHandler;

	iUnsolicitedHandler = NULL;

	delete iWaitForCall;

	iWaitForCall = NULL;

	}

CLtsyCallControlHandler* CLtsyCallControlHandler::NewLC(

	CCtsyDispatcherCallback& aCtsyDispatcherCallback,

	CGlobalPhonemanager* aGloblePhone)

	{

	TSYLOGENTRYEXIT;

	CLtsyCallControlHandler* self = new (ELeave) CLtsyCallControlHandler(aCtsyDispatcherCallback,aGloblePhone);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CLtsyCallControlHandler* CLtsyCallControlHandler::NewL(CCtsyDispatcherCallback& aCtsyDispatcherCallback, CGlobalPhonemanager* aGloblePhone)

	{

	TSYLOGENTRYEXIT;

	CLtsyCallControlHandler* self=

			CLtsyCallControlHandler::NewLC(aCtsyDispatcherCallback, aGloblePhone);

	CleanupStack::Pop(self);

	return self;

	}

void CLtsyCallControlHandler::ConstructL()

/**

 * Second phase constructor.

 */

	{	

	//Emergency Call

	iEmergencyCall = CATDialVoice::NewL((*iGloblePhone),iCtsyDispatcherCallback);

	iEmergencyCall->SetEmergnecyCallFlag(ETrue);

	//Process unsolicited command

	iUnsolicitedHandler = CUnsolicitedCommandCallControlHandler::NewL((*iGloblePhone), 

			                                                          iCtsyDispatcherCallback);

	//Monitor incoming call

	iWaitForCall = CATWaitForCallHandler::NewL((*iGloblePhone), iCtsyDispatcherCallback);

	iWaitForCall->StartToWaitForCall();

	} // CLtsyCallControlHandler::ConstructL

TBool CLtsyCallControlHandler::IsInterfaceSupported(TLtsyDispatchInterfaceApiId aDispatchApiId)

/**

 * Returns whether a Dispatch Interface API is supported or not.

 *

 * @param aDispatchApiId Id of Dispatch interface being queried

 * @return indication whether interface is supported or not

 */

	{

	TBool bFlag(EFalse);

	switch(aDispatchApiId)

		{

		// Insert ApiIds when support is provided in LTSY

		case MLtsyDispatchCallControlAnswer::KLtsyDispatchCallControlAnswerApiId :

			bFlag =  ETrue;

			break;		

		case MLtsyDispatchCallControlHold::KLtsyDispatchCallControlHoldApiId:

			bFlag =  ETrue;

			break;

		case MLtsyDispatchCallControlHangUp::KLtsyDispatchCallControlHangUpApiId :

			bFlag =  ETrue;

			break;

		case MLtsyDispatchCallControlResume::KLtsyDispatchCallControlResumeApiId :

			bFlag = ETrue;

			break;

		case MLtsyDispatchCallControlDialVoice::KLtsyDispatchCallControlDialVoiceApiId :

			bFlag =  ETrue;

			break;		

		case MLtsyDispatchCallControlSwap::KLtsyDispatchCallControlSwapApiId :

			bFlag = ETrue;

			break;

		case MLtsyDispatchCallControlTerminateErrorCall::KLtsyDispatchCallControlTerminateErrorCallApiId :

			bFlag = ETrue;

			break;

		case MLtsyDispatchCallControlTerminateAllCalls::KLtsyDispatchCallControlTerminateAllCallsApiId :

			bFlag = ETrue;

			break;

		case MLtsyDispatchCallControlSendDtmfTones::KLtsyDispatchCallControlSendDtmfTonesApiId :

			bFlag = ETrue;

			break;

		case MLtsyDispatchCallControlStartDtmfTone::KLtsyDispatchCallControlStartDtmfToneApiId :

			bFlag = ETrue;

			break;

		case MLtsyDispatchCallControlStopDtmfTone::KLtsyDispatchCallControlStopDtmfToneApiId :

			bFlag = ETrue;

			break;

		case MLtsyDispatchCallControlSendDtmfTonesCancel::KLtsyDispatchCallControlSendDtmfTonesCancelApiId :

			bFlag = ETrue;

			break;

		case MLtsyDispatchCallControlQueryIsEmergencyNumber::KLtsyDispatchCallControlQueryIsEmergencyNumberApiId :

			bFlag = ETrue;

			break;

		case MLtsyDispatchCallControlDialEmergency::KLtsyDispatchCallControlDialEmergencyApiId :

			bFlag = ETrue;

			break;

		default:

			bFlag = EFalse;

			break;

		}

	return bFlag;

	}

void CLtsyCallControlHandler::IsCallbackIndicatorSupported(TLtsyDispatchIndIdGroup aIdGroup, TUint32& aIndIdBitMask)

/**

 * Returns the set of callback indicators that are supported.

 *

 * @param aIdGroup ID of group that is being queried e.g. aIdGroup=EIndIdGroup1

 * @param aIndIdBitMask [out] argument that should return a bitmask indicating which indicator callbacks are supported.

 */

	{

	//Create bitmask with bitset for each indicator ID that is supported. E.g.

	if(aIdGroup == EIndIdGroup1)

		aIndIdBitMask = KLtsyDispatchCallControlNotifyCallStatusChangeIndId |

		KLtsyDispatchCallControlReceiveUuiIndId |

		KLtsyDispatchCallControlNotifyDataCallCapsChangeIndId|

		KLtsyDispatchCallControlNotifyIncomingCallIndId|

		KLtsyDispatchCallControlNotifyHscsdInfoChangeIndId|

		KLtsyDispatchCallControlNotifyCallEventIndId|

		KLtsyDispatchCallControlGetCallInfoIndId|

		KLtsyDispatchCallControlNotifyIccCallForwardingStatusChangeIndId;

	else

		aIndIdBitMask = 0; //no indicators from other groups supported

	}

TInt CLtsyCallControlHandler::HandleAnswerReqL(TInt aCallId, TBool aIsIsvCall)

/**

 * This request is completed by invoking

 * CCtsyDispatcherCallback::CallbackCallControlAnswerComp()

 *

 * @param aCallId The Call ID of the call to answer.

 *

 * @param aIsIsvCall ETrue if the request to answer the call comes from a

 * 3rd party application, EFalse otherwise. This parameter exists in case the

 * LTSY wishes to perform special handling of ISV calls.

 *

 * @return KErrNone on success, KErrNotSupported if this request is not supported,

 * or another error code to indicate the failure otherwise.

 */

	{

	LOGTEXT( _L8("[Ltsy CallControl]  Starting CLtsyCallControlHandler::HandleAnswerReqL()"));

	TInt nEmergencyCallId = iGloblePhone->GetCallInfoManager().FindEmergencyCallId();

	if (nEmergencyCallId != KErrNotFound)

		{

		const TLtsyCallInformation& tCallInfo(iGloblePhone->GetCallInfoManager().GetCallInformationByCallId(nEmergencyCallId));

		if (TLtsyCallInformation::EHeldCall  !=  tCallInfo.GetCallState())

			{

			//Reset Ring state

			iGloblePhone->GetCallInfoManager().SetIncomingCallFlag(EFalse);			

			return KErrNotSupported;

			}

		}	

	TInt nRet = iGloblePhone->CheckGlobalPhoneStatus();

	if (nRet == KErrNone)

		{

		//Reset Ring state

		iGloblePhone->GetCallInfoManager().SetIncomingCallFlag(EFalse);

		//Setting Port active

		iGloblePhone->iEventSignalActive = ETrue;

		//Create answer call

		CATAnswer* cAnswerCall = CATAnswer::NewL((*iGloblePhone), iCtsyDispatcherCallback);

		iGloblePhone->SetActiveRequest(cAnswerCall);

		cAnswerCall->SetAnswerCallId(aCallId);

		cAnswerCall->SetIsIsvCall(aIsIsvCall);

		//Start answer

		cAnswerCall->StartRequest();		

		}

	return nRet;

	} // CLtsyCallControlHandler::HandleAnswerReqL

TInt CLtsyCallControlHandler::HandleHoldReqL(TInt aCallId)

/**

 * This request is completed by invoking

 * CCtsyDispatcherCallback::CallbackCallControlHoldComp()

 *

 * @param aCallId The Call ID of the call to hold.

 *

 * @return KErrNone on success, KErrNotSupported if this request is not supported,

 * or another error code to indicate the failure otherwise.

 */

	{

	LOGTEXT(_L8("[Ltsy CallControl]  Starting CLtsyCallControlHandler::HandleHoldReqL"));

	LOGTEXT2(_L8("[Ltsy CallControl] aCallId = %d"), aCallId);

	TInt nRet = iGloblePhone->CheckGlobalPhoneStatus();

	if (nRet == KErrNone)

		{

		//Setting Port active

		iGloblePhone->iEventSignalActive = ETrue;

		//Create hold call

		CATChld* cHoldCall = CATChld::NewL((*iGloblePhone), iCtsyDispatcherCallback);

		iGloblePhone->SetActiveRequest(cHoldCall);

		//Check call id is a hold call or not

		if (cHoldCall->IsHoldCall(aCallId))

			{

			LOGTEXT2(_L8("[Ltsy CallControl] aCallId = %d is a hold call so return KErrNone"), aCallId);

			iGloblePhone->iEventSignalActive = EFalse;

			return KErrNotSupported;

			}

		cHoldCall->SetCallId(aCallId);

		cHoldCall->SetIpcType(CATChld::ELtsyReqCallHold);

		cHoldCall->SetChldType(CATChld::EHeldAllActiveCallAndAcceptHeldWaiting);

		cHoldCall->StartRequest();			

		}

	return nRet;

	} // CLtsyCallControlHandler::HandleHoldReqL

TInt CLtsyCallControlHandler::HandleDialEmergencyReqL(const TDes& aEmergencyNumber)

/**

 * This request is completed by invoking

 * CCtsyDispatcherCallback::CallbackCallControlDialEmergencyComp()

 *

 * @param aEmergencyNumber The emergency phone number to dial.  The descriptor

 * should be of type RMobileENStore::TEmergencyNumber.

 *

 * @return KErrNone on success, KErrNotSupported if this request is not supported,

 * or another error code to indicate the failure otherwise.

 */

	{

	LOGTEXT(_L8("[Ltsy CallControl]  Starting CLtsyCallControlHandler::HandleDialEmergencyReqL()"));

	//Checking is have emergency call

	if (iGloblePhone->GetCallInfoManager().FindEmergencyCallId() != KErrNotFound)

		{

		return KErrNotSupported;

		}

	TBuf8<RMobilePhone::KMaxMobileTelNumberSize> tTelNum;

	tTelNum.Copy(aEmergencyNumber.Left(tTelNum.MaxLength()));

	TInt nRet = iGloblePhone->CheckGlobalPhoneStatus();

	if (nRet == KErrNone)

		{

		//Setting Port active

		iGloblePhone->iEventSignalActive = ETrue;

		//Init call

		iEmergencyCall->InitVariable();

		//Set telnum

		iEmergencyCall->SetTelephoneNumber(tTelNum);

		iEmergencyCall->StartRequest();

		}

	else // KErrInUse

		{

		if (iGloblePhone->GetCallInfoManager().FindDialingOrAlertingCallId() != KErrNotFound)

			{

			//Delete last call

			iGloblePhone->DeleteLastActiveRequest();

			//Setting Port active

			iGloblePhone->iEventSignalActive = ETrue;

			//Init call

			iEmergencyCall->InitVariable();

			//Set telnum

			iEmergencyCall->SetTelephoneNumber(tTelNum);

			iEmergencyCall->StartRequest();

			nRet = KErrNone;

			}	

		}

	return nRet;

	} // CLtsyCallControlHandler::HandleDialEmergencyReqL

TInt CLtsyCallControlHandler::HandleStopDtmfToneReqL(TInt aCallId)

/**

 * This request is completed by invoking

 * CCtsyDispatcherCallback::CallbackCallControlStopDtmfToneComp()

 *

 * @param aCallId Call ID of the connected call the stop request will be sent

 * through.

 *

 * @return KErrNone on success, KErrNotSupported if this request is not supported,

 * or another error code to indicate the failure otherwise.

 */

	{

	LOGTEXT(_L8("[Ltsy CallControl]  Starting CLtsyCallControlHandler::HandleStopDtmfToneReqL()"));

	LOGTEXT2( _L8("[Ltsy CallControl] CallId = %d"), aCallId);

	TInt nRet = iGloblePhone->CheckGlobalPhoneStatus();

	if (nRet == KErrNone)

		{

		//Setting Port active

		iGloblePhone->iEventSignalActive = ETrue;

		//Create DTMF 

		CATDtmfVts* cDtmfVts = CATDtmfVts::NewL((*iGloblePhone), iCtsyDispatcherCallback);

		iGloblePhone->SetActiveRequest(cDtmfVts);

		//Set CallId

		nRet = cDtmfVts->SetCallId(aCallId);

		if (nRet != KErrNone)

			{

			return nRet;

			}	

		//Set work type

		cDtmfVts->SetDtmfWorkType(CATDtmfVts::EDtmfStopOneTone);

		//Start request

		cDtmfVts->StartRequest();		

		}	

	return nRet;

	} // CLtsyCallControlHandler::HandleStopDtmfToneReqL

TInt CLtsyCallControlHandler::HandleSetActiveAlsLineReqL(RMobilePhone::TMobilePhoneALSLine /*aAlsLine*/)

/**

 * This request is completed by invoking

 * CCtsyDispatcherCallback::CallbackCallControlSetActiveAlsLineComp()

 *

 * @param aAlsLine The new active ALS line.

 *

 * @return KErrNone on success, KErrNotSupported if this request is not supported,

 * or another error code to indicate the failure otherwise.

 */

	{

	TSYLOGENTRYEXIT;

	TInt ret = KErrNotSupported;

	// TODO: Add implementation here.......

	return TSYLOGSETEXITERR(ret);

	} // CLtsyCallControlHandler::HandleSetActiveAlsLineReqL

TInt CLtsyCallControlHandler::HandleSendDtmfTonesCancelReqL(TInt aCallId)

/**

 * This request is completed by invoking

 * CCtsyDispatcherCallback::CallbackCallControlSendDtmfTonesCancelComp()

 *

 * @param aCallId The Call ID through which the cancel request should be sent.

 *

 * @return KErrNone on success, KErrNotSupported if this request is not supported,

 * or another error code to indicate the failure otherwise.

 */

	{

	LOGTEXT(_L8("[Ltsy CallControl]  Starting CLtsyCallControlHandler::HandleSendDtmfTonesCancelReqL()"));

	LOGTEXT2( _L8("[Ltsy CallControl] CallId = %d"), aCallId);

	TInt nRet = iGloblePhone->CheckGlobalPhoneStatus();

	if (nRet == KErrNone)

		{

		//Setting Port active

		iGloblePhone->iEventSignalActive = ETrue;

		//Create DTMF 

		CATDtmfVts* cDtmfVts = CATDtmfVts::NewL((*iGloblePhone), iCtsyDispatcherCallback);

		iGloblePhone->SetActiveRequest(cDtmfVts);

		//Set CallId

		nRet = cDtmfVts->SetCallId(aCallId);

		if (nRet != KErrNone)

			{

			return nRet;

			}	

		//Set work type

		cDtmfVts->SetDtmfWorkType(CATDtmfVts::EDtmfCancelMoreTones);

		//Start request

		cDtmfVts->StartRequest();		

		}

	return nRet;

	} // CLtsyCallControlHandler::HandleSendDtmfTonesCancelReqL

TInt CLtsyCallControlHandler::HandleHangUpReqL(TInt aCallId, TInt aHangupCause)

/**

 * This request is completed by invoking

 * CCtsyDispatcherCallback::CallbackCallControlHangUpComp()

 *

 * @param aCallId The Call ID of the call to hang up.

 *

 * @param aHangupCause The reason for the hang up request.

 *

 * @return KErrNone on success, KErrNotSupported if this request is not supported,

 * or another error code to indicate the failure otherwise.

 */

	{

	LOGTEXT( _L8("[Ltsy CallControl]  Starting CLtsyCallControlHandler::HandleHangUpReqL"));

	LOGTEXT3(_L8("[Ltsy CallControl]  aCallId = %d aHangupCause = %d"), aCallId, aHangupCause);

	TInt nRet = iGloblePhone->CheckGlobalPhoneStatus();

	if (nRet == KErrNone)

		{

		//Setting Port active

		iGloblePhone->iEventSignalActive = ETrue;

		//Reset Ring state

		iGloblePhone->GetCallInfoManager().SetIncomingCallFlag(EFalse);

		//Set hang up active

		iGloblePhone->GetCallInfoManager().GetHangupCommandRecords().SetHangupActiveFlag(ETrue);

		//Create Hang up  

		CATChld* cHangupCall = CATChld::NewL((*iGloblePhone), iCtsyDispatcherCallback);

		iGloblePhone->SetActiveRequest(cHangupCall);

		cHangupCall->SetCallId(aCallId);

		cHangupCall->SetHangupCase(aHangupCause);

		cHangupCall->SetIpcType(CATChld::ELtsyReqCallHangup);

		cHangupCall->SetChldType(CATChld::ERleaseSpecificCall);

		cHangupCall->StartRequest();			

		}

	else if (nRet == KErrInUse)

		{

		LOGTEXT( _L8("[Ltsy CallControl]  Starting Hang up in process so add hangup information"));

		const TLtsyCallInformation& tCallInfo(iGloblePhone->GetCallInfoManager().GetCallInformationByCallId(aCallId));

		if (iGloblePhone->GetCallInfoManager().GetHangupCommandRecords().GetHangupActiveFlag())

			{

			//Hang up is processing so add its information to array

			nRet = iGloblePhone->GetCallInfoManager().GetHangupCommandRecords().AddHangupCommandInfo(aCallId, aHangupCause);					

			}

		else if (TLtsyCallInformation::EDialingCall  ==  tCallInfo.GetCallState() ||

				 TLtsyCallInformation::EAlertingCall ==  tCallInfo.GetCallState())

			{

			//Delete last call

			iGloblePhone->DeleteLastActiveRequest();

			//Setting Port active

			iGloblePhone->iEventSignalActive = ETrue;	

			//Set hang up active

			iGloblePhone->GetCallInfoManager().GetHangupCommandRecords().SetHangupActiveFlag(ETrue);

			//Create Hang up  

			CATChld* cHangupCall = CATChld::NewL((*iGloblePhone), iCtsyDispatcherCallback);

			iGloblePhone->SetActiveRequest(cHangupCall);

			cHangupCall->SetCallId(aCallId);

			cHangupCall->SetHangupCase(aHangupCause);

			cHangupCall->SetIpcType(CATChld::ELtsyReqCallHangup);

			cHangupCall->SetChldType(CATChld::ERleaseSpecificCall);

			cHangupCall->StartRequest();

			nRet = KErrNone;

			}

		}	

	return nRet;

	} // CLtsyCallControlHandler::HandleHangUpReqL

TInt CLtsyCallControlHandler::HandleResumeReqL(TInt aCallId)