// 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:

// This file contains the implementation of the Simulator TSY call classes.  The call classes

// process the call-based requests made by ETel clients and passed down to the TSY by the

// ETel Server.

// 

//

/**

 @file

*/

#include "CSimCall.h"

#include "CSimPhone.h"

void CSimCall::CloseCall(TAny* aObj)

/**

* Utility func for cleanup stack

*

* @param aObj a pointer to the CObject to close

*/

	{

	((CObject*)aObj)->Close();

	}

CSimCall::CSimCall(CSimLine* aLine,const TName& aName, CSimPhone* aPhone)

			: iState(RMobileCall::EStatusIdle),iLine(aLine), 

			  iHookState(ConvertStateToHook(iState)), iPhone(aPhone)

	{

	iNotifyStatusChange.iNotifyPending = EFalse;

	iMobileNotifyStatusChange.iNotifyPending = EFalse;

	iAnswerIncomingCall.iNotifyPending = EFalse;

	iName.Copy(aName);

	}

void CSimCall::ConstructL()

/**

* Standard constructor

*/

	{

	iCallDurationHandler = CSimCallDuration::NewL(this);

	iNotifyRemotePartyInfoTimer = CSimCallRemotePartyInfoChange::NewL(this);

	}

CSimCall::~CSimCall()

/**

* Standard destructor

*/

	{

	iLine->CallDestructor(this);

	delete iCallDurationHandler;

	delete iNotifyRemotePartyInfoTimer;

	}

CTelObject::TReqMode CSimCall::ReqModeL(const TInt aIpc)

/**

* This function returns the Request Mode for the request with the passed IPC value.

* The ETel Server provides a function for returning the standard request modes for

* the Core API requests.

* Multimode API requests mode are handled here.

*

* @param aIpc the IPc number representing the client request

* @return CTelObject::TReqMode the request mode to be used for this IPc number

* @leave Leaves if the IPc number is not found

*/

	{

	// ReqModeL is called from the server's CTelObject::ReqAnalyserL

	// in order to check the type of request it has

	CTelObject::TReqMode reqMode=0;

	switch (aIpc)

		{

	//

	// No Flow Control NOR Multiple Completion

	//

	case EMobileCallGetMobileDataCallCaps:

	case EMobileCallGetMobileCallCaps:

	case EMobileCallGetMobileCallStatus:

	case EMobileCallGetMobileCallInfo:

	case EMobileCallDialEmergencyCall:

	case EMobileCallGetMobileDataCallRLPRange:

	case EMobileCallSetDynamicHscsdParams:

	case EMobileCallGetCurrentHscsdInfo:

	case EMobileCallHold:

	case EMobileCallResume:

	case EMobileCallSwap:

	case EMobileCallAnswerISV:

		break;

	//

	// Flow Control Obeyed

	//

	case EMobileCallDialISV:

		reqMode=KReqModeFlowControlObeyed;

		break;

	//

	// Multiple Completion Services with Immediate Server Repost

	// (Usually Notifications)

	//

	case EMobileCallNotifyHscsdInfoChange:

	case EMobileCallNotifyMobileCallStatusChange:

	case EMobileCallNotifyMobileCallCapsChange:

	case EMobileCallNotifyRemotePartyInfoChange:

		reqMode=KReqModeMultipleCompletionEnabled | KReqModeRePostImmediately;

		break;

	default:

		reqMode=CCallBase::ReqModeL(aIpc);

		break;

	}

	return reqMode;

	}

TInt CSimCall::NumberOfSlotsL(const TInt aIpc)

/**

* NumberOfSlotsL is called by the server when it is registering a new notification

* It enables the TSY to tell the server how many buffer slots to allocate for

* "repost immediately" notifications that may trigger before clients collect them

*

* @param aIpc the IPc number representing the client request

* @return TInt the number of slots required

* @leave Leaves if the IPc number is not found

*/

	{

	switch (aIpc)

		{

	case EMobileCallNotifyHscsdInfoChange:

	case EMobileCallNotifyMobileDataCallCapsChange:

	case EMobileCallNotifyMobileCallStatusChange:

	case EMobileCallNotifyMobileCallCapsChange:

	case EMobileCallNotifyRemotePartyInfoChange:

		return KDefaultNumberOfSlots;

	default:

		break;

		}

	return CCallBase::NumberOfSlotsL(aIpc);

	}

TInt CSimCall::RegisterNotification(const TInt /*aIpc*/)

/**

* The ETel Server calls this function when the first client makes a notification

* request.  If supported by the underlying protocol controlling the

* signalling stack, this can be used to start requesting updates for the relevant service.

*/

	{

	return KErrNone;

	}

TInt CSimCall::DeregisterNotification(const TInt /*aIpc*/)

/**

* The ETel Server calls this function when the last client that had previously

* made a notification request closes its ETel Server handle.  If supported by

* the underlying protocol controlling the	signalling stack, this can be used

* to stop requesting updates for the relevant service.

*/

	{

	return KErrNone;

	}

void CSimCall::Init()

/**

* This function can be used to perform any necessary synchronous initialisation.

*/

	{}

TInt CSimCall::GetCaps(const TTsyReqHandle aTsyReqHandle,RCall::TCaps* aCallCaps)

/**

* Retrieve the Call capabilities

*

* @param aTsyReqHandle	TSY handle associated with this request.s

* @param aCallCaps		Pointer to the call capability

* @return KErrNone

*/

	{

	aCallCaps->iFlags=iCaps;

	ReqCompleted(aTsyReqHandle,KErrNone);

	return KErrNone;

	}

TInt CSimCall::NotifyCapsChange(const TTsyReqHandle aTsyReqHandle, RCall::TCaps* aCaps)

/**

* Register a client's interest in being notified when the call caps change.

* @param aTsyReqHandle	The TSY handle associated with this request.

* @param aCaps			The capability structure that will be populated with the new capability

*						information.

* @return TInt			Standard error code.

*/

	{

	__ASSERT_ALWAYS(!iNotifyCapsChange.iNotifyPending,SimPanic(ENotificationReqAlreadyOutstanding));

	iNotifyCapsChange.iNotifyPending=ETrue;

	iNotifyCapsChange.iNotifyHandle=aTsyReqHandle;

	iNotifyCapsChange.iNotifyData=aCaps;

	return KErrNone;

	}

TInt CSimCall::NotifyCapsChangeCancel(const TTsyReqHandle /*aTsyReqHandle*/)

/**

* Cancel a client's interest in being notified when the call capabilities change.

*/

	{

	if(iNotifyCapsChange.iNotifyPending)

		{

		iNotifyCapsChange.iNotifyPending=EFalse;

		ReqCompleted(iNotifyCapsChange.iNotifyHandle,KErrCancel);

		}

	return KErrNone;

	}

TInt CSimCall::GetMobileCallCaps(const TTsyReqHandle aTsyReqHandle, TDes8* aCaps)

/**

* Retrieve the Mobile Call capabilities

*

* @param aTsyReqHandle	TSY handle associated with this request.

* @param aCaps			Pointer to the call capability

* @return KErrNone

*/

	{

	TPckg<RMobileCall::TMobileCallCapsV1>* capsPckg=(TPckg<RMobileCall::TMobileCallCapsV1>*)aCaps;

	RMobileCall::TMobileCallCapsV1& caps=(*capsPckg)();

	// Check that the data structure is supported by the simulated TSY version

	TInt err = iPhone->CheckSimTsyVersion(caps);

	if(err != KErrNone)

		{

		ReqCompleted(aTsyReqHandle, err);

		return KErrNone;

		}

	caps.iCallControlCaps=iCaps;		// None of the extended caps are supported.

	caps.iCallEventCaps=0;

	ReqCompleted(aTsyReqHandle,KErrNone);

	return KErrNone;

	}

TInt CSimCall::NotifyMobileCallCapsChange(const TTsyReqHandle aTsyReqHandle, TDes8* aCaps)

/**

* Register a client's interest in being notified when the RMobileCall capabilities change.

* @param aTsyReqHandle	The TSY handle associated with this request.

* @param aCaps			The capability structure that will be populated with the new capability

*						information.

* @return TInt			Standard error code.

*/

	{

	__ASSERT_ALWAYS(!iNotifyMobileCapsChange.iNotifyPending,SimPanic(ENotificationReqAlreadyOutstanding));

	iNotifyMobileCapsChange.iNotifyPending=ETrue;

	iNotifyMobileCapsChange.iNotifyHandle=aTsyReqHandle;

	iNotifyMobileCapsChange.iNotifyData=aCaps;

	return KErrNone;

	}

TInt CSimCall::NotifyMobileCallCapsChangeCancel(const TTsyReqHandle /*aTsyReqHandle*/)

/**

* Cancel a client's interest in being notified when the RMobileCall capabilities change.

*/

	{

	if(iNotifyMobileCapsChange.iNotifyPending)

		{

		iNotifyMobileCapsChange.iNotifyPending=EFalse;

		ReqCompleted(iNotifyMobileCapsChange.iNotifyHandle,KErrCancel);

		}

	return KErrNone;

	}

TInt CSimCall::NotifyHookChange(const TTsyReqHandle aTsyReqHandle, RCall::THookStatus* aHookStatus)

/**

* Record a client's interst in being notified when the hook changes state.

*

* @param aTsyReqHandle Tsy Request handle for the client request

* @param aHookStatus pointer to the hook status

* @return KErrNone

*/

	{

	iNotifyHookChange.iNotifyPending = ETrue;

	iNotifyHookChange.iNotifyHandle = aTsyReqHandle;

	iNotifyHookChange.iNotifyData = aHookStatus;

	return KErrNone;

	}

TInt CSimCall::NotifyHookChangeCancel(const TTsyReqHandle /*aTsyReqHandle*/)

/**

* Cancel a client's interest in being notified when the hook state changes.

*

* @param aTsyReqHandle Tsy Request handle for the client cancel request

* @return KErrNone

*/

	{

	if(iNotifyHookChange.iNotifyPending)

		{

		iNotifyHookChange.iNotifyPending=EFalse;

		ReqCompleted(iNotifyHookChange.iNotifyHandle,KErrCancel);

		}

	return KErrNone;

	}

TInt CSimCall::NotifyMobileCallStatusChange(const TTsyReqHandle aTsyReqHandle,RMobileCall::TMobileCallStatus* aStatus)

/**

* Record a client's interest in being notified when the call status changes.

* First check that there isn't already a notification pending (the ETel Server should protect

* against this) and then record the information necessary to complete the request later, when

* the status does actually change.

*

* @param aTsyReqHandle Tsy Request handle for the client request

* @param aStatus pointer to the call status

* @return KErrNone

*/

	{

	__ASSERT_ALWAYS(!iMobileNotifyStatusChange.iNotifyPending,SimPanic(ENotificationAlreadyPending));

	iMobileNotifyStatusChange.iNotifyPending = ETrue;

	iMobileNotifyStatusChange.iNotifyHandle = aTsyReqHandle;

	iMobileNotifyStatusChange.iNotifyData = aStatus;

	return KErrNone;

	}

TInt CSimCall::NotifyMobileCallStatusChangeCancel(const TTsyReqHandle /*aTsyReqHandle*/)

/**

* Cancel a client's interest in being notified when the call status changes.

* This is acheived simply by resetting the flag that indicates a notification is pending.

* 

* @param aTsyReqHandle Tsy Request handle for the client cancel request

* @return KErrNone

*/

	{

	if(iMobileNotifyStatusChange.iNotifyPending)

		{

		iMobileNotifyStatusChange.iNotifyPending=EFalse;

		ReqCompleted(iMobileNotifyStatusChange.iNotifyHandle,KErrCancel);

		}

	return KErrNone;

	}

TInt CSimCall::NotifyStatusChange(const TTsyReqHandle aTsyReqHandle,RCall::TStatus* aStatus)

/**

* Record a client's interest in being notified when the call status changes.

* First check that there isn't already a notification pending (the ETel Server should protect

* against this) and then record the information necessary to complete the request later, when

* the status does actually change.

*

* @param aTsyReqHandle Tsy Request handle for the client request

* @param aStatus pointer to the call status

* @return KErrNone

*/

	{

	__ASSERT_ALWAYS(!iNotifyStatusChange.iNotifyPending,SimPanic(ENotificationAlreadyPending));

	iNotifyStatusChange.iNotifyPending = ETrue;

	iNotifyStatusChange.iNotifyHandle = aTsyReqHandle;

	iNotifyStatusChange.iNotifyData = aStatus;

	return KErrNone;

	}

TInt CSimCall::NotifyStatusChangeCancel(const TTsyReqHandle /*aTsyReqHandle*/)

/**

*	Cancel a client's interest in being notified when the call status changes.

*	This is acheived simply by resetting the flag that indicates a notification is pending.

* 

* @param aTsyReqHandle Tsy Request handle for the client cancel request

* @return KErrNone

*/

	{

	if(iNotifyStatusChange.iNotifyPending)

		{

		iNotifyStatusChange.iNotifyPending=EFalse;

		ReqCompleted(iNotifyStatusChange.iNotifyHandle,KErrCancel);

		}

	return KErrNone;

	}

TInt CSimCall::NotifyDurationChange(const TTsyReqHandle aTsyReqHandle,TTimeIntervalSeconds* aTime)

/**

* Record a client's interest in being notified when the call duration changes.

* 

* @param aTsyReqHandle

* @param aTime

* @return KErrNone or symbian wide error code

*/

	{

	iCallDurationHandler->StartNotification(aTsyReqHandle, aTime);

	return KErrNone;

	}

TInt CSimCall::NotifyDurationChangeCancel(const TTsyReqHandle /*aTsyReqHandle*/)

/**

* Not Supported in this TSY

*/

	{

	iCallDurationHandler->StopNotification();

	return KErrNone;

	}

TInt CSimCall::GetInfo(const TTsyReqHandle aTsyReqHandle, RCall::TCallInfo* aCallInfo)

/**

* Retrieve the Call Information.

*

* @param aTsyReqHandle

* @param aCallInfo pointer to the call information to be returned to client

* @return KErrNone

*/

	{

	aCallInfo->iCallName.Copy(iName);

	aCallInfo->iLineName.Copy(iLine->iLineName);

	aCallInfo->iHookStatus=ConvertStateToHook(iState);

	aCallInfo->iStatus=GetCoreCallStatus();

	aCallInfo->iDuration=0;

	ReqCompleted(aTsyReqHandle,KErrNone);

	return KErrNone;

	}

TInt CSimCall::GetMobileCallInfo(const TTsyReqHandle aTsyReqHandle, TDes8* aMobileCallInfo)

/**

* Retrieve the Mobile Call Information

*

* @param aTsyReqHandle

* @param aCallInfo pointer to the call information to be returned to client

* @return KErrNone

*/

	{

	RMobileCall::TMobileCallInfoV1Pckg* mobileCallInfoV1=(RMobileCall::TMobileCallInfoV1Pckg*)aMobileCallInfo;

	RMobileCall::TMobileCallInfoV1& mobileCallInfo=(*mobileCallInfoV1)();

	// Check that the data structure is supported by the simulated TSY version

	TInt err = iPhone->CheckSimTsyVersion(mobileCallInfo);

	if(err != KErrNone)

		{

		ReqCompleted(aTsyReqHandle, err);

		return KErrNone;

		}

	TUint caps=Caps();

	if(caps&RCall::KCapsVoice)

		mobileCallInfo.iService=RMobilePhone::EVoiceService;

	else if(caps&RCall::KCapsData)

		mobileCallInfo.iService=RMobilePhone::ECircuitDataService;

	else if(caps&RCall::KCapsFax)

		mobileCallInfo.iService=RMobilePhone::EFaxService;

	else

		mobileCallInfo.iService=RMobilePhone::EServiceUnspecified;

	mobileCallInfo.iValid=0x0;

	mobileCallInfo.iStatus=iState;

	mobileCallInfo.iCallName.Copy(iName);

	mobileCallInfo.iLineName.Copy(iLine->iLineName);

	ReqCompleted(aTsyReqHandle,KErrNone);

	return KErrNone;

	}

RCall::TStatus CSimCall::GetCoreCallStatus()

/**

* Converts Multimode call status (RMobileCall::TMobileCallStatus) to 

*          Core call Status (RCall::TStatus)

*

* @return RCall::TStatus The core call status

*/

	{

// All status enums with values of Disconnecting and below are identical in

// ETelMM and Core, so the mapping function is simple.

	RCall::TStatus coreStatus;

	if (iState <= RMobileCall::EStatusDisconnecting)

		coreStatus = (RCall::TStatus)iState;

	else

		switch (iState)

		{

		case RMobileCall::EStatusReconnectPending:

		case RMobileCall::EStatusHold:

			coreStatus = RCall::EStatusConnected;

			break;

		case RMobileCall::EStatusWaitingAlternatingCallSwitch:

			coreStatus = RCall::EStatusIdle;

			break;

		default:

			coreStatus = RCall::EStatusUnknown;

			break;

		}

	return coreStatus;

	}

TInt CSimCall::GetStatus(const TTsyReqHandle aTsyReqHandle, RCall::TStatus* aCallStatus)

/**

* Return the current call state. (Core API request)

*

* @param aTsyReqHandle

* @param aCallStatus pointer to the call status

* @return KErrNone