/*

* Copyright (c) 2009 Sony Ericsson Mobile Communications AB

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

* Sony Ericsson Mobile Communications AB - initial contribution.

* Nokia Corporation - additional changes.

* 

* Contributors:

* 

* Description:

* Code for TelephonyFuncLine class, used by CTelephony class.

*

*/

/**

 @file

*/

#include <e32def.h>

#include "TelephonyFunctions.h"

#include "TelephonyActCall.h"

#include "TelephonyActLine.h"

TInt CTelephonyFunctions::DialNewCallL(TRequestStatus& aRequestStatus, TDes8& aCallParams, 

		const CTelephony::TTelNumber& aTelNumber, CTelephony::TCallId& aCallId, const CTelephony::TPhoneLine aLine)

/**

Dial a new call. 

*/

	{

	TName myCallName;

	if(aLine != CTelephony::EVoiceLine)

		{

		return KErrAccessDenied;

		}

	if(IsRequestPending(CTelephonyFunctions::EDialNewCall)!=EFalse)

		{

		return KErrInUse;

		}

	else

		{

		SetRequestPending(CTelephonyFunctions::EDialNewCall, ETrue);

		}

	CTelephony::TCallId myCallId;

	if(GetISVCall(myCallId) != KErrNone)

		{

		return KErrAccessDenied;

		}

	if(!iDialNewCall)

		{

		iDialNewCall = CDialNewCallAct::NewL(this);

		}

	if(IsFlightModeOn())

		{

		return KErrAccessDenied;

		}

	// 1. If call object has not been previously opened then call OpenNewCall.

	// 2. If the call object was previously opened and used for an AnswerIncomingCall we close the object and then call re-open it with OpenNewCall.

	// 3. If call object was previously opened and used for a dial then can re-use it. 

	switch(iCallPoolStatus[myCallId])

		{

	case EAnswer:

		CloseAndReset(myCallId);

	case EUnset:

		User::LeaveIfError(iCallPool[myCallId].OpenNewCall(iLineVoice, myCallName));	

		break;

	case EDial:

	default:

		break;	

		}		

	iCallPoolStatus[myCallId]=EDial;

	iReqStatusTable[EDialNewCall] = &aRequestStatus;

	iDialNewCall->DialNewCall(aCallParams,aTelNumber,aCallId,myCallId);	

	return KErrNone;

	}

TInt CTelephonyFunctions::HoldL(TRequestStatus& aRequestStatus, const CTelephony::TCallId& aCallId) 

/**

Attempt to place a call on hold.

*/

	{

	if((aCallId != CTelephony::EISVCall1) &&

			(aCallId != CTelephony::EISVCall2))

		{

		return KErrAccessDenied;

		}

	if(IsRequestPending(CTelephonyFunctions::EHold)!=EFalse)

		{

		return KErrInUse;

		}

	else

		{

		SetRequestPending(CTelephonyFunctions::EHold, ETrue);

		}

	if(IsFlightModeOn())

		{

		return KErrAccessDenied;

		}

	RMobileCall::TMobileCallStatus callStatus;

	if(Call(aCallId)!=NULL)

		{

		Call(aCallId)->GetMobileCallStatus(callStatus);

		if(callStatus!=RMobileCall::EStatusConnected)

			return KErrAccessDenied;

		}

	else

		{

		return KErrAccessDenied;

		}

	if(!iHold)

		{

		iHold = CHoldAct::NewL(this);

		}

	iReqStatusTable[EHold] = &aRequestStatus;

	iHold->Hold(aCallId);	

	return KErrNone;

	}

TInt CTelephonyFunctions::ResumeL(TRequestStatus& aRequestStatus, const CTelephony::TCallId& aCallId) 

/**

Attempt to Resume a previously held call

*/

	{

	if((aCallId != CTelephony::EISVCall1) &&

			(aCallId != CTelephony::EISVCall2))

		{

		return KErrAccessDenied;

		}

	if(IsRequestPending(CTelephonyFunctions::EResume)!=EFalse)

		{

		return KErrInUse;

		}

	else

		{

		SetRequestPending(CTelephonyFunctions::EResume, ETrue);

		}

	if(IsFlightModeOn())

		{

		return KErrAccessDenied;

		}

	RMobileCall::TMobileCallStatus callStatus;

	if(Call(aCallId)!=NULL)

		{

		Call(aCallId)->GetMobileCallStatus(callStatus);

		if(callStatus!=RMobileCall::EStatusHold)

			return KErrAccessDenied;

		}

	else

		{

		return KErrAccessDenied;

		}

	if(!iResume)

		{

		iResume = CResumeAct::NewL(this);

		}

	iReqStatusTable[EResume] = &aRequestStatus;

	iResume->Resume(aCallId);	

	return KErrNone;

	}

TInt CTelephonyFunctions::SwapL(TRequestStatus& aRequestStatus, const CTelephony::TCallId& aCallId1, const 

					  CTelephony::TCallId& aCallId2) 

/**

Attempt to swap the currently held and active calls.

*/

	{

	if(!((aCallId1 == CTelephony::EISVCall1 &&

		  aCallId2 == CTelephony::EISVCall2) ||

			(aCallId1 == CTelephony::EISVCall2 &&

			aCallId2 == CTelephony::EISVCall1)

			))

		{

		return KErrAccessDenied;

		}

	if(IsRequestPending(CTelephonyFunctions::ESwap)!=EFalse)

		{

		return KErrInUse;

		}

	else

		{

		SetRequestPending(CTelephonyFunctions::ESwap, ETrue);

		}

	if(IsFlightModeOn())

		{

		return KErrAccessDenied;

		}

	RMobileCall::TMobileCallStatus callStatus1, callStatus2;

	if((Call(aCallId1)!=NULL) && (Call(aCallId2)!=NULL))

		{

		Call(aCallId1)->GetMobileCallStatus(callStatus1);

		Call(aCallId2)->GetMobileCallStatus(callStatus2);

		if (!( ((callStatus1==RMobileCall::EStatusConnected) &&

			  (callStatus2==RMobileCall::EStatusHold)) ||

		      ((callStatus1==RMobileCall::EStatusHold) &&

		    	(callStatus2==RMobileCall::EStatusConnected))))

		    {

			return KErrAccessDenied;

			}

		}

	else

		{

		return KErrAccessDenied;

		}

	if(!iSwap)

		{

		iSwap = CSwapAct::NewL(this);

		}

	iReqStatusTable[ESwap] = &aRequestStatus;

	iSwap->Swap(aCallId1);	

	return KErrNone;

	}

TInt CTelephonyFunctions::HangupL(TRequestStatus& aRequestStatus, const CTelephony::TCallId& aCallId) 

/**

Attempt to hangup a call.

*/

	{

	if((aCallId != CTelephony::EISVCall1) &&

			(aCallId != CTelephony::EISVCall2))

		{

		return KErrAccessDenied;

		}

	if(IsRequestPending(CTelephonyFunctions::EHangup)!=EFalse)

		{

		return KErrInUse;

		}

	else

		{

		SetRequestPending(CTelephonyFunctions::EHangup, ETrue);

		}

	if(IsFlightModeOn())

		{

		return KErrAccessDenied;

		}

	RMobileCall::TMobileCallStatus callStatus;

	if(Call(aCallId)!=NULL)

		{

		Call(aCallId)->GetMobileCallStatus(callStatus);

		if(callStatus!=RMobileCall::EStatusHold &&

		   callStatus!=RMobileCall::EStatusConnected && 

		   callStatus!=RMobileCall::EStatusConnecting &&

		   callStatus!=RMobileCall::EStatusRinging &&

		   callStatus!=RMobileCall::EStatusAnswering)

		   {

		   return KErrAccessDenied;

		   }

		}

	else

		{

		return KErrAccessDenied;

		}

	if(!iHangup)

		{

		iHangup = CHangupAct::NewL(this);

		}

	iReqStatusTable[EHangup] = &aRequestStatus;	

	iHangup->Hangup(aCallId);	

	return KErrNone;

	}

/**

Attempt to answer an incoming call.

This can only be done with a voice line.

*/

TInt CTelephonyFunctions::AnswerIncomingCallL(TRequestStatus& aRequestStatus, CTelephony::TCallId& aCallId, 

		const CTelephony::TPhoneLine aLine)

	{

	if(aLine != CTelephony::EVoiceLine)

		{

		return KErrAccessDenied;

		}

	if(IsRequestPending(CTelephonyFunctions::EAnswerIncomingCall)!=EFalse)

		{

		return KErrInUse;

		}

	else

		{

		SetRequestPending(CTelephonyFunctions::EAnswerIncomingCall, ETrue);

		}

	// Get free call line.  If none available then return.

	CTelephony::TCallId myCallId;

	if(GetISVCall(myCallId) != KErrNone)

		{

		return KErrAccessDenied;

		}

	if(IsFlightModeOn())

		{

		return KErrAccessDenied;

		}

	RMobileCall::TMobileCallStatus callStatus;

	// Check that the line is in the ringing state.  

	// If it is not then there is no call to answer 

	// so return.

	User::LeaveIfError(iLineVoice.GetMobileLineStatus(callStatus));

	if(callStatus!=RMobileCall::EStatusRinging)

		{

		return KErrAccessDenied;

		}	

	// Our call pool object (returned from GetISVCall() above) may 

	// have been previously used.

	// This means a OpenExistingCall or OpenNewCall has been called 

	// previously which must be closed before we call 

	// OpenExistingCall again.

	if(iCallPoolStatus[myCallId]==EAnswer || iCallPoolStatus[myCallId]==EDial)

		{

		CloseAndReset(myCallId);

		}

	//Create an answer call AO.	

	if(iAnswerIncomingCall == NULL)

		{

		iAnswerIncomingCall = CAnswerIncomingCallAct::NewL(this, *iInternalNotifyIncomingCall, iCallPool, iCallPoolStatus);

		}

	iReqStatusTable[EAnswerIncomingCall] = &aRequestStatus;	

	// Initiate answer call request.	

	iAnswerIncomingCall->AnswerIncomingCall(aCallId,myCallId);	

	return KErrNone;

	}

/**

Retrieve the current call status.

*/

TInt CTelephonyFunctions::GetCallStatusL(const CTelephony::TCallId& aCallId, TDes8& aStatus)

	{

	if((aCallId != CTelephony::EISVCall1) &&

			(aCallId != CTelephony::EISVCall2))

		{

		return KErrAccessDenied;

		}

	CTelephony::TCallStatusV1& CallStatusV1 = 

			reinterpret_cast<CTelephony::TCallStatusV1&> ( const_cast<TUint8&> ( *aStatus.Ptr() ) );

	RMobileCall::TMobileCallStatus callStatus=RMobileCall::EStatusUnknown;

	if(Call(aCallId) == NULL)

		{

		return KErrAccessDenied;

		}

	if(IsFlightModeOn())

		{

		return KErrAccessDenied;

		}

	User::LeaveIfError(Call(aCallId)->GetMobileCallStatus(callStatus));

	GetCallStatus(callStatus, CallStatusV1.iStatus);

	return KErrNone;

	}	

void CTelephonyFunctions::GetCallStatus(const RMobileCall::TMobileCallStatus aMMCallStatus, CTelephony::TCallStatus& aTelCallStatus)

/**

Map RMobileCall::TMobileCallStatus to CTelephony::TCallStatus

*/

	{

	switch(aMMCallStatus)

		{

	case RMobileCall::EStatusUnknown:

		aTelCallStatus=CTelephony::EStatusUnknown;

		break;

	case RMobileCall::EStatusIdle:

		aTelCallStatus=CTelephony::EStatusIdle;

		break;

	case RMobileCall::EStatusDialling:

		aTelCallStatus=CTelephony::EStatusDialling;

		break;

	case RMobileCall::EStatusRinging:

		aTelCallStatus=CTelephony::EStatusRinging;

		break;

	case RMobileCall::EStatusAnswering:

		aTelCallStatus=CTelephony::EStatusAnswering;

		break;

	case RMobileCall::EStatusConnecting:

		aTelCallStatus=CTelephony::EStatusConnecting;

		break;

	case RMobileCall::EStatusConnected:

		aTelCallStatus=CTelephony::EStatusConnected;

		break;

	case RMobileCall::EStatusReconnectPending:

		aTelCallStatus=CTelephony::EStatusReconnectPending;

		break;

	case RMobileCall::EStatusDisconnecting:

	case RMobileCall::EStatusDisconnectingWithInband:

		aTelCallStatus=CTelephony::EStatusDisconnecting;

		break;

	case RMobileCall::EStatusHold:

		aTelCallStatus=CTelephony::EStatusHold;

		break;

	case RMobileCall::EStatusTransferring:

		aTelCallStatus=CTelephony::EStatusTransferring;

		break;

	case RMobileCall::EStatusTransferAlerting:

		aTelCallStatus=CTelephony::EStatusTransferAlerting;

		break;

	default:

		aTelCallStatus=CTelephony::EStatusUnknown;

		break;

		}

	}

TInt CTelephonyFunctions::GetCallDynamicCaps(const CTelephony::TCallId& aCallId, TDes8& aCaps)

/**

Retrieve the calls dynamic capabilities.

*/

	{

	if((aCallId != CTelephony::EISVCall1) &&

			(aCallId != CTelephony::EISVCall2))

		{

		return KErrAccessDenied;

		}

	CTelephony::TCallCapsV1& CallCapsV1 = *( reinterpret_cast<CTelephony::TCallCapsV1*> 

												( const_cast<TUint8*> ( aCaps.Ptr() ) ) );

	RMobileCall::TMobileCallCapsV1 callCaps;

	RMobileCall::TMobileCallCapsV1Pckg callCapsPckg(callCaps);

	if(Call(aCallId)==NULL)

		{

		return KErrAccessDenied;

		}

	if(IsFlightModeOn())

		{

		return KErrAccessDenied;

		}

	TInt ret = Call(aCallId)->GetMobileCallCaps(callCapsPckg);	 

	// Set the call control capability

	CallCapsV1.iControlCaps = 0;

	if 	(callCaps.iCallControlCaps & RMobileCall::KCapsHold)

	  CallCapsV1.iControlCaps |= CTelephony::KCapsHold;

	if 	(callCaps.iCallControlCaps & RMobileCall::KCapsResume)

	  CallCapsV1.iControlCaps |= CTelephony::KCapsResume;

	if 	(callCaps.iCallControlCaps & RMobileCall::KCapsSwap)

	  CallCapsV1.iControlCaps |= CTelephony::KCapsSwap;		

	return ret;

	}