--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cbsref/telephonyrefplugins/atltsy/handler/src/cltsycallcontrolhandler.cpp	Tue Aug 31 16:23:08 2010 +0300
@@ -0,0 +1,1155 @@
+// 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)
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackCallControlResumeComp()
+ *
+ * @param aCallId The Call ID of the call to resume.
+ *
+ * @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::HandleResumeReqL"));
+	LOGTEXT2(_L8("[Ltsy CallControl] aCallId = %d"), aCallId);	
+
+	TInt nRet = iGloblePhone->CheckGlobalPhoneStatus();
+	if (nRet == KErrNone)
+		{
+		//Setting Port active
+		iGloblePhone->iEventSignalActive = ETrue;
+		
+		//Create DTMF 
+		CATChld* cResumeCall = CATChld::NewL((*iGloblePhone), iCtsyDispatcherCallback);
+		iGloblePhone->SetActiveRequest(cResumeCall);
+		if (cResumeCall->IsActiveCall(aCallId))
+			{
+			LOGTEXT2(_L8("[Ltsy CallControl] aCallId = %d is a active call so return KErrNone"), aCallId);
+			iGloblePhone->iEventSignalActive = EFalse;
+			return KErrNotSupported;
+			}
+		cResumeCall->SetCallId(aCallId);
+		cResumeCall->SetIpcType(CATChld::ELtsyReqCallResume);
+		cResumeCall->SetChldType(CATChld::EHeldAllActiveCallAndAcceptHeldWaiting);
+		cResumeCall->StartRequest();		
+		}
+	
+	return nRet;
+	} // CLtsyCallControlHandler::HandleResumeReqL
+
+TInt CLtsyCallControlHandler::HandleSetDynamicHscsdParamsReqL(
+	TInt /*aCallId*/, const RMobileCall::TMobileHscsdCallParamsV1& /*aHscsdParams*/)
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackCallControlSetDynamicHscsdParamsComp()
+ *
+ * @param aCallId The call ID of the data call.
+ *
+ * @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::HandleSetDynamicHscsdParamsReqL
+
+
+TInt CLtsyCallControlHandler::HandleDialVoiceReqL(RMobilePhone::TMobilePhoneALSLine /*aLine*/,
+	const RMobilePhone::TMobileAddress& aDialledParty, const RMobileCall::TMobileCallParamsV1& /*aCallParamsV1*/,
+	TBool /*aIsIsvCall*/, RMobileCall::TCallParamOrigin /*aCallOrigin*/, TBool /*aPerformFdnCheck*/)
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackCallControlDialVoiceComp()
+ *
+ * @param aCallLine The line to use to dial the call.
+ *
+ * @param aDialledParty Details about the dialled party including the phone
+ * number to dial.
+ *
+ * @param aCallParamsV1 The call parameters of the call to dial.
+ *
+ * @param aIsIsvCall Indicates whether the call originated from a third party
+ * application.
+ *
+ * @param aCallOrigin The origin of the dial request. e.g. Whether the dial
+ * came from an Etel client or the SIM or another source.
+ *
+ * @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::HandleDialVoiceReqL()"));
+	
+	TInt nEmergencyCallId = iGloblePhone->GetCallInfoManager().FindEmergencyCallId();
+	if (nEmergencyCallId != KErrNotFound)
+		{
+		const TLtsyCallInformation& tCallInfo(iGloblePhone->GetCallInfoManager().GetCallInformationByCallId(nEmergencyCallId));
+		if (TLtsyCallInformation::EHeldCall  !=  tCallInfo.GetCallState())
+			{
+			return KErrNotSupported;
+			}
+		}
+	
+	//Set telephone number
+	TBuf8<KCommsDbSvrMaxFieldLength> dialModifier;
+	TInt nRet = iGloblePhone->iConfiguration->ConfigModemStringL(
+								TPtrC(KCDTypeNameDialToneWaitModifier),
+								dialModifier);
+	if (nRet != KErrNone)
+		{
+		return nRet;
+		}
+	
+	TBuf8<RMobilePhone::KMaxMobileTelNumberSize> tTelNum;
+	tTelNum.Copy(aDialledParty.iTelNumber.Left(tTelNum.MaxLength()));
+	
+	nRet = tTelNum.FindF(dialModifier);
+	if (nRet != KErrNotFound)
+		{
+		tTelNum.Delete(nRet, 1);
+		}
+	
+	nRet = iGloblePhone->CheckGlobalPhoneStatus();
+	if (nRet == KErrNone)
+		{
+		//Setting Port active
+		iGloblePhone->iEventSignalActive = ETrue;
+		
+		//Create dial voice
+		CATDialVoice* cDialVoice = CATDialVoice::NewL((*iGloblePhone), iCtsyDispatcherCallback);
+		iGloblePhone->SetActiveRequest(cDialVoice);
+		cDialVoice->SetTelephoneNumber(tTelNum);
+		cDialVoice->StartRequest();
+		}
+	
+	return nRet;
+	} // CLtsyCallControlHandler::HandleDialReqL
+
+TInt CLtsyCallControlHandler::HandleTransferReqL(TInt /*aHeldCallId*/, TInt /*aSecondCallId*/)
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackCallControlTransferComp()
+ *
+ * @param aHeldCallId Call ID of the held call to transfer.
+ *
+ * @param aSecondCallId Call ID of the other to transfer the held call to.
+ *
+ * @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::HandleTransferReqL
+
+
+TInt CLtsyCallControlHandler::HandleSendDtmfTonesReqL(TInt aCallId, const TDesC &aTones)
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackCallControlSendDtmfTonesComp()
+ *
+ * @param aCallId The Call ID of the call through which the DTMF string will be
+ * sent.
+ *
+ * @param aTones Tones to send through the active call.
+ *
+ * @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::HandleSendDtmfTonesReqL()"));
+	LOGTEXT3( _L8("[Ltsy CallControl] CallId = %d\tTones = %S"), aCallId, &aTones);
+	
+	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
+		TInt nRet = cDtmfVts->SetCallId(aCallId);
+		if (nRet != KErrNone)
+			{
+			return nRet;
+			}	
+		
+		//Set Tones
+		nRet = cDtmfVts->SetDtmfString(aTones);
+		if (nRet != KErrNone)
+			{
+			return nRet;
+			}	
+		
+		//set work type
+		cDtmfVts->SetDtmfWorkType(CATDtmfVts::EDtmfSendMoreTones);
+		cDtmfVts->StartRequest();
+		}	
+	
+	return nRet;
+	} // CLtsyCallControlHandler::HandleSendDtmfTonesReqL
+
+
+TInt CLtsyCallControlHandler::HandleGetIdentityServiceStatusReqL(RMobilePhone::TMobilePhoneIdService /*aService*/)
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackCallControlGetIdentityServiceStatusComp()
+ *
+ * @param aService The service whose status needs to be retrieved.
+ *
+ * @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::HandleGetIdentityServiceStatusReqL
+
+
+TInt CLtsyCallControlHandler::HandleSwapReqL(TInt aHeldCallId, TInt aConnectedCallId)
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackCallControlSwapComp()
+ *
+ * @param aHeldCallId The Call ID of the held call to swap.
+ *
+ * @param aConnectedCallId The Call ID of the connected call to swap.
+ *
+ * @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::HandleSwapReqL"));
+	LOGTEXT3(_L8("[Ltsy CallControl] aHeldCallId = %d\taConnectedCallId = %d"), aHeldCallId, aConnectedCallId);
+	
+	TInt nRet = iGloblePhone->CheckGlobalPhoneStatus();
+	if (nRet == KErrNone)
+		{
+		//Setting Port active
+		iGloblePhone->iEventSignalActive = ETrue;
+		
+		//Create DTMF 
+		CATChld* cSwapCall = CATChld::NewL((*iGloblePhone), iCtsyDispatcherCallback);
+		iGloblePhone->SetActiveRequest(cSwapCall);
+		cSwapCall->SetCallId(aHeldCallId);
+		cSwapCall->SetConnectedCallId(aConnectedCallId);
+		cSwapCall->SetIpcType(CATChld::ELtsyReqCallSwap);
+		cSwapCall->SetChldType(CATChld::EHeldAllActiveCallAndAcceptHeldWaiting);
+		cSwapCall->StartRequest();			
+		}
+	
+	return nRet;
+	} // CLtsyCallControlHandler::HandleSwapReqL
+
+TInt CLtsyCallControlHandler::HandleLoanDataPortSyncL(TInt /*aCallId*/, RCall::TCommPort& /*aCommPort*/)
+/**
+ * This request is part of
+ * MLtsyDispatchCallControlLoanDataPort::HandleLoanDataPortSyncL()
+ *
+ * @param aCallId Call ID of the data call requiring the data port.
+ *
+ * @param aCommPort Output parameter. The communications port information
+ * retrieved by a client using the RCall::LoanDataPort() API.
+ *
+ * @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::HandleLoanDataPortSyncL
+
+
+TInt CLtsyCallControlHandler::HandleRecoverDataPortSyncL(TInt /*aCallId*/, RCall::TCommPort& /*aCommPort*/)
+/**
+ * This request is part of
+ * MLtsyDispatchCallControlRecoverDataPort::HandleRecoverDataPortSyncL()
+ *
+ * @param aCallId Call ID of the data call requiring the data port.
+ *
+ * @param aCommPort The data port to recover.  This contains the details previously
+ * returned by a call to RCall::LoanDataPort()
+ *
+ * @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::HandleRecoverDataPortSyncL
+
+
+TInt CLtsyCallControlHandler::HandleStartDtmfToneReqL(TInt aCallId, const TChar& aTone)
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackCallControlStartDtmfTone()
+ *
+ * @param aCallId Call ID of the connected call through which the DTMF tone
+ * will be sent.
+ *
+ * @param aTone The tone character to send through the call.
+ *
+ * @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::HandleStartDtmfToneReqL()"));
+	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
+		TInt nRet = cDtmfVts->SetCallId(aCallId);
+		if (nRet != KErrNone)
+			{
+			return nRet;
+			}	
+		
+		//Set Tones
+		TBuf<16> bufTone;
+		bufTone.Append(aTone);
+		nRet = cDtmfVts->SetDtmfString(bufTone);
+		if (nRet != KErrNone)
+			{
+			return nRet;
+			}
+		
+		//set work type
+		cDtmfVts->SetDtmfWorkType(CATDtmfVts::EDtmfSendOneTone);
+		cDtmfVts->StartRequest();
+		}
+	
+	return nRet;	
+	} // CLtsyCallControlHandler::HandleStartDtmfToneSyncL
+
+TInt CLtsyCallControlHandler::HandleGetActiveAlsLineReqL()
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackCallControlGetActiveAlsLineComp()
+ *
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise.
+ */
+	{
+	TSYLOGENTRYEXIT;
+
+	TInt ret = KErrNotSupported;
+
+	// TO DO: Add implementation here.......
+
+
+	return TSYLOGSETEXITERR(ret);
+	} // CLtsyCallControlHandler::HandleGetActiveAlsLineReqL
+
+TInt CLtsyCallControlHandler::HandleDialDataReqL(const RMobilePhone::TMobileAddress& /*aDialledParty*/, const RMobileCall::TMobileDataCallParamsV1& /*aCallParamsV1*/, TBool /*aPerformFdnCheck*/)
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackCallControlGetActiveAlsLineComp()
+ *
+ * @param aLine The line to use to dial the call.
+ *
+ * @param aDialledParty Details about the dialled party including the phone
+ * number to dial.
+ *
+ * @param aCallParamsV1 The call parameters of the call to dial.
+ *
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise.
+ */
+	{
+	TSYLOGENTRYEXIT;
+
+	TInt ret = KErrNotSupported;
+
+	// TO DO: Add implementation here.......
+
+
+	return TSYLOGSETEXITERR(ret);
+	} // CLtsyCallControlHandler::HandleDialDataReqL
+
+TInt CLtsyCallControlHandler::HandleQueryIsEmergencyNumberSyncL(const TDesC& aNumber, TBool& aIsEmergencyNumber)
+/**
+ * This request is part of
+ * MLtsyDispatchCallControlQueryIsEmergencyNumber::HandleQueryIsEmergencyNumberSyncL()
+ *
+ * @param aNumber Input parameter. The phone number being queried to see
+ * if it is an emergency number or not.
+ *
+ * @param aIsEmergencyNumber Output parameter used to indicate whether the
+ * aNumber parameter is an emergency number. ETrue if it is, EFalse otherwise.
+ *
+ * @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::HandleQueryIsEmergencyNumberSyncL()"));
+	
+	TInt nEmergencyCallId = iGloblePhone->GetCallInfoManager().FindEmergencyCallId();
+	if (nEmergencyCallId != KErrNotFound)
+		{
+		const TLtsyCallInformation& tCallInfo(iGloblePhone->GetCallInfoManager().GetCallInformationByCallId(nEmergencyCallId));
+		if (TLtsyCallInformation::EHeldCall  !=  tCallInfo.GetCallState())
+			{			
+			return KErrNotSupported;
+			}
+		}	
+	
+	//Check Emergency call number	
+	if (aNumber.CompareF(KLtsyEmergencyCallNumber911) == 0 ||
+		aNumber.CompareF(KLtsyEmergencyCallNumber112) == 0 )
+		{
+		aIsEmergencyNumber = ETrue;
+		}
+	else
+		{
+		aIsEmergencyNumber = EFalse;
+		}
+	
+	return KErrNone;
+	} // CLtsyCallControlHandler::HandleQueryIsEmergencyNumberSyncL
+
+
+TInt CLtsyCallControlHandler::HandleGetAlsPpSupportL()
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackCallControlGetAlsPpSupportComp()
+ *
+ * @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::HandleGetAlsPp
+
+TInt CLtsyCallControlHandler::HandleGetAlsBlockedStatusL()
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackCallControlGetAlsBlockedStatusComp()
+ *
+ * @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::HandleGetAlsBlockedStatus
+
+TInt CLtsyCallControlHandler::HandleSetAlsBlockedL(RMmCustomAPI::TSetAlsBlock /*aBlocked*/)
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackCallControlSetAlsBlockedComp()
+ *
+ *
+ * @param aBlocked RMmCustomAPI::EDeactivateBlock when the ALS blocked needs to be deactivate,
+ *                 RMmCustomAPI::EActivateBlock when the  ALS blocked needs to be activate.
+ *
+ * @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::HandleSetAlsBlockedL
+
+TInt CLtsyCallControlHandler::HandleGetLifeTimeL()
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackCallControlGetLifeTimeComp()
+ *
+ * @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::HandleGetLifeTime
+
+TInt CLtsyCallControlHandler::HandleTerminateErrorCallL(TInt /*aCallId*/)
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackCallControlTerminateErrorCallComp()
+ *
+ *
+ * @param aCallId The Call ID of the call to terminate.
+ *
+ * @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::HandleTerminateErrorCallL
+
+TInt CLtsyCallControlHandler::HandleTerminateAllCallsL()
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::::CallbackCallControlTerminateAllCallsComp()
+ *
+ * @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::HandleTerminateAllCallsL()"));
+	
+	TInt nRet = iGloblePhone->CheckGlobalPhoneStatus();
+	if (nRet == KErrNone)
+		{
+		//Setting Port active
+		iGloblePhone->iEventSignalActive = ETrue;
+		
+		//Reset Ring state
+		iGloblePhone->GetCallInfoManager().SetIncomingCallFlag(EFalse);		
+		
+		CATHangUp* cTerminateAllCalls = CATHangUp::NewL((*iGloblePhone), iCtsyDispatcherCallback);
+		iGloblePhone->SetActiveRequest(cTerminateAllCalls);
+		cTerminateAllCalls->SetHangupOperator(CATHangUp::ECustomAPI);
+		cTerminateAllCalls->StartRequest();	
+		}
+	
+	return nRet;
+	} // CLtsyCallControlHandler::HandleTerminateAllCallsL
+
+TInt CLtsyCallControlHandler::HandleGetCallForwardingIndicatorL()
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackCallControlGetCallForwardingIndicatorComp()
+ *
+ * @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::HandleGetCallForwardingIndicator
+
+TInt CLtsyCallControlHandler::HandleUpdateLifeTimerReqL(TUint32 /*aDuration*/)
+/**
+ * This request is completed by invoking
+ *  CCtsyDispatcherCallback::CallbackCallControlUpdateLifeTimerComp
+ *
+ * @param aDuration Time spent on call since the last invocation of this method.
+ *
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise.
+ */
+	{
+	TSYLOGENTRYEXIT;
+
+	TInt ret = KErrNotSupported;
+
+	// TO DO: Add implementation here.......
+
+
+	return TSYLOGSETEXITERR(ret);
+	} // CLtsyCallControlHandler:::HandleUpdateLifeTimerReqL
+
+
+MLtsyUnsolicitedCommandObserver* CLtsyCallControlHandler::GetUnsolicitedCallControlHandler() const
+	{
+	return static_cast<MLtsyUnsolicitedCommandObserver*>(iUnsolicitedHandler);
+	}
+
+//End of file