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

//

#include "ET_SSTD.H"

#include "ETBUFFER.H"

#include <f32file.h>

#include "etsvr_slots.h"

#include "et_phone_util.h"

//

//

// CFaxBase

//

//

EXPORT_C CFaxBase::CFaxBase()

//

//	C'Tor

//

	{

	__DECLARE_NAME(_S("CFaxBase"));

	}

EXPORT_C CFaxBase::~CFaxBase()

//

//	D'Tor

//

	{}

EXPORT_C CTelObject* CFaxBase::OpenNewObjectByNameL(const TDesC&)

//

// Always return NULL not allow CFaxBase Tsy object to create new object

//

	{

	User::Leave(KErrNotSupported);

	return NULL;

	}

EXPORT_C CTelObject* CFaxBase::OpenNewObjectL(TDes&)

//

// Always return NULL not allow CFaxBase Tsy object to create new object

//

	{

	User::Leave(KErrNotSupported);

	return NULL;

	}

EXPORT_C void CFaxBase::OpenPostProcessing(CTelSession*,const TInt)

//

// Perform post-processing after object has been added to session's CObjectIx.

//

	{}

EXPORT_C void CFaxBase::CloseSubSessionPreProcessing(CTelSession* aSession,const TInt aSubSessionHandle)

	{

	CreateDummySession(aSession,aSubSessionHandle);

	FlushReqs(aSession,aSubSessionHandle);

	}

EXPORT_C TInt CFaxBase::CancelService(const TInt aIpc,const TTsyReqHandle /*aTsyReqHandle*/)

//

// Cancel Service for Fax

//

	{

	__ASSERT_ALWAYS((aIpc==EEtelFaxRead) ||

					(aIpc==EEtelFaxWrite) ||

					(aIpc==EEtelFaxWaitForEndOfPage)

					,Fault(EEtelFaultInvalidIpcForCancel));

	switch (aIpc)

		{

	// this is a special case for Fax session - 

	// count already increment before calling susession

	// for those reqs below - server do expect Tsy to call ReqCompleted()

	// so the count should be decrement again !

	case EEtelFaxRead:

	case EEtelFaxWrite:

	case EEtelFaxWaitForEndOfPage:

		return KErrNone;	

		// There is no individual cancel associated with these requests

	default:

		return KErrGeneral;

		}

	}

EXPORT_C TInt CFaxBase::Service(const RMessage2& /*aMessage*/,CReqEntry* aReqEntry)

//

// The ServiceL functionality for the fax

//

	{

	__ASSERT_ALWAYS(aReqEntry!=NULL,Fault(EEtelFaultCallTsyServiceWithoutReqPackage));

	aReqEntry->iPlacedRequest=ETrue;

	TTsyReqHandle tsyReqHandle=aReqEntry->iTsyReqHandle;

	TDes8* des1 = BufferDes1(aReqEntry->iBuffer,CBuffer::ESlotWrite);

	switch (aReqEntry->iFunction)

		{

	case EEtelFaxRead:

		__ASSERT_ALWAYS(des1!=NULL,Fault(EETelFaultRequestWithoutBuffer));

		return Read(tsyReqHandle,des1);

	case EEtelFaxWrite:

		__ASSERT_ALWAYS(des1!=NULL,Fault(EETelFaultRequestWithoutBuffer));

		return Write(tsyReqHandle,des1);

	case EEtelFaxWaitForEndOfPage:

		return WaitForEndOfPage(tsyReqHandle);

	case EEtelFaxTerminateFaxSession:

		return TerminateFaxSession(tsyReqHandle);

	default:

		return KErrNotSupported;

		}

	}

EXPORT_C void CFaxBase::Init()

	{}

EXPORT_C CTelObject::TReqMode CFaxBase::ReqModeL(const TInt aIpc)

//

// Fax Request Inquiry Functions

//

    {

	CTelObject::TReqMode mode=0;

	switch (aIpc)

		{

	case EEtelFaxTerminateFaxSession:

		mode=KReqModeMultipleCompletionEnabled;	// if two clients call this, only want the first to

											// be acted upon

		break;

	case EEtelFaxRead:

	case EEtelFaxWrite:

	case EEtelFaxWaitForEndOfPage:

		mode=KReqModeFlowControlObeyed;

		break;

	default:

		User::Leave(KErrNotSupported);

		break;

		}

	return mode;

	}

EXPORT_C TInt CFaxBase::NumberOfSlotsL(const TInt /*aIpc*/)

	{

	User::Leave(KErrNotSupported);	// there are no repost immediately functions for fax

	return KSlotNumbersDefault;

	}

//

//

// CCallBase

//

//

EXPORT_C CCallBase::CCallBase()

//

//	C'Tor

//

	:iOwnershipStatus(EOwnedUnowned)

	,iOwnerSession(NULL)

	,iOwnerSubSessionHandle(0)

	,iLoanDataPort(EFalse)

	{

	__DECLARE_NAME(_S("CCallBase"));

	}

EXPORT_C CCallBase::~CCallBase()

//

//	D'Tor

//	Attual closing of the owner is done in CSubSessionBase destructor

//	This is for all object inherit fron CSubSessionBase

//

	{

	}

EXPORT_C TInt CCallBase::CancelService(const TInt aIpc,const TTsyReqHandle aTsyReqHandle)

//

// Cancel Service for Call

//

	{

	__ASSERT_ALWAYS((aIpc==EEtelCallNotifyHookChange) ||

					(aIpc==EEtelCallNotifyStatusChange) ||

					(aIpc==EEtelCallNotifyDurationChange) ||

					(aIpc==EEtelCallCapsChangeNotification) ||

					(aIpc==EEtelCallAcquireOwnership) ||

					(aIpc==EEtelCallDial) ||

					(aIpc==EEtelCallAnswer) ||

					(aIpc==EEtelCallHangUp) ||

					(aIpc==EEtelCallConnect)||

					(aIpc==EEtelCallLoanDataPort)

					,Fault(EEtelFaultInvalidIpcForCancel));

	switch (aIpc)

		{

	case EEtelCallCapsChangeNotification:

		return NotifyCapsChangeCancel(aTsyReqHandle);

	case EEtelCallNotifyHookChange:

		return NotifyHookChangeCancel(aTsyReqHandle);

	case EEtelCallNotifyStatusChange:

		return NotifyStatusChangeCancel(aTsyReqHandle);

	case EEtelCallNotifyDurationChange:

		return NotifyDurationChangeCancel(aTsyReqHandle);

	case EEtelCallAcquireOwnership:

		return AcquireOwnershipCancel(aTsyReqHandle);

	case EEtelCallDial:

		return DialCancel(aTsyReqHandle);

	case EEtelCallConnect:

		return ConnectCancel(aTsyReqHandle);

	case EEtelCallAnswer:

		return AnswerIncomingCallCancel(aTsyReqHandle);

	case EEtelCallHangUp:

		return HangUpCancel(aTsyReqHandle);

	case EEtelCallLoanDataPort:

		return LoanDataPortCancel(aTsyReqHandle);

	default:

		return KErrGeneral; // should never reached here

		}

	}

EXPORT_C void CCallBase::Init()

	{}

EXPORT_C CCallBase::TCallOwnership CCallBase::CheckOwnership(const TTsyReqHandle aTsyReqHandle) const

//

// Tsy upcall function - return the call ownership status

//

	{

	CReqEntry* reqEntry=PhoneOwner()->FindByTsyHandle(aTsyReqHandle);

	__ASSERT_ALWAYS(reqEntry!=NULL,Fault(EEtelFaultNotRecognisedTsyHandle));

	RCall::TOwnershipStatus owner=CheckOwnershipBySession(reqEntry->iSession,reqEntry->iMessage.Int3());

	if (owner==RCall::EOwnershipUnowned)

		return EOwnedUnowned;

	if (owner==RCall::EOwnershipOwnedByThisClient)

		return EOwnedTrue;

	if (owner==RCall::EOwnershipThisIsPriorityClient)

		return EOwnedPriorityClient; 

	return EOwnedFalse;

	}

EXPORT_C RCall::TOwnershipStatus CCallBase::CheckOwnershipBySession(CTelSession* aSession,const TInt /*aSubSessionHandle*/) const

//

// Return true if the owner

//

	{

	if (iOwnershipStatus==EOwnedUnowned)

		return RCall::EOwnershipUnowned;

	if(iOwnershipStatus==EOwnedTrue && iOwnerSession==aSession /*&& iOwnerSubSessionHandle==aSubSessionHandle*/)	// ownership is session based!

		return RCall::EOwnershipOwnedByThisClient;

// Ann changed

	if (iOwnershipStatus==EOwnedTrue && aSession->TelServer()->IsPriorityClient(aSession))

		return RCall::EOwnershipThisIsPriorityClient;

// end

	return RCall::EOwnershipOwnedByAnotherClient;

	}

EXPORT_C TInt CCallBase::SetUnowned()

//

// Return Owner ship status

//

	{

	iOwnershipStatus=EOwnedUnowned;

	iOwnerSession=NULL; // set to invalid value

	iOwnerSubSessionHandle=0; 

	return KErrNone;

	}

EXPORT_C TInt CCallBase::SetOwnership(const TTsyReqHandle aTsyReqHandle)

//

// If owner ship if not own

//

	{

	CReqEntry* reqEntry=PhoneOwner()->FindByTsyHandle(aTsyReqHandle);

	__ASSERT_ALWAYS(reqEntry!=NULL,Fault(EEtelFaultNotRecognisedTsyHandle));

	iOwnershipStatus=EOwnedTrue;

	iOwnerSession=reqEntry->iSession;

	iOwnerSubSessionHandle=reqEntry->iMessage.Int3();

	return KErrNone;

	}

EXPORT_C TBool CCallBase::CheckPriorityClient(const TTsyReqHandle aTsyReqHandle) const

	{

	CReqEntry* reqEntry=PhoneOwner()->FindByTsyHandle(aTsyReqHandle);

	__ASSERT_ALWAYS(reqEntry!=NULL,Fault(EEtelFaultNotRecognisedTsyHandle));

	return reqEntry->iSession->TelServer()->IsPriorityClient(reqEntry->iSession);

	}		

EXPORT_C CCallBase* CCallBase::ResolveSubSessionHandle(const TTsyReqHandle aTsyReqHandle,

													   const TInt aSubSessionHandle)

//

//	expects the subsession handle of a call, which must have been opened by the same client session

//	which opened this call and called the current request (identified by aTsyReqHandle)

//

	{

	CReqEntry* reqEntry=PhoneOwner()->FindByTsyHandle(aTsyReqHandle);

	__ASSERT_ALWAYS(reqEntry!=NULL,Fault(EEtelFaultNotRecognisedTsyHandle));

	return REINTERPRET_CAST(CCallBase*,reqEntry->iSession->CObjectFromHandle(aSubSessionHandle));

	}

EXPORT_C void CCallBase::OpenPostProcessing(CTelSession* ,const TInt)

//

// Perform post-processing after object has been added to session's CObjectIx.

//

	{}

EXPORT_C void CCallBase::CloseSubSessionPreProcessing(CTelSession* aSession,const TInt aSubSessionHandle)

//

// Perform close post-processing before object being close

// if is owner then set to EUnOwned

//

	{

	CreateDummySession(aSession,aSubSessionHandle);

	RCall::TOwnershipStatus owner=CheckOwnershipBySession(aSession,aSubSessionHandle);

	if (owner==RCall::EOwnershipOwnedByThisClient)

		{

		CreateDummySession(aSession,aSubSessionHandle,ETrue);

		if (iLoanDataPort)  // data port being on loan by this owner

			RecoverDataPortAndRelinquishOwnership(); // inform tsy about this

		else

			RelinquishOwnership();

		}

	FlushReqs(aSession,aSubSessionHandle);	

	}

EXPORT_C void CCallBase::RelinquishOwnershipCompleted(const TInt aError)

//

// Server called Tsy with RelinquishOwnership()

// TSY should do a Up call with this function

//

	{

	__ASSERT_ALWAYS(aError==KErrNone,Fault(EEtelFaultCanNotRelinquishOwnership));

	CheckAndDestroyDummySubSession();

	}

EXPORT_C void CCallBase::RecoverDataPortAndRelinquishOwnershipCompleted(const TInt aError)

//

// Server called Tsy with RecoverDataPortAndRelinquishOwnership()

// TSY should do a Up call with this function

//

	{

	__ASSERT_ALWAYS(aError==KErrNone,Fault(EEtelFaultCanNotRelinquishOwnership));

	iLoanDataPort=EFalse;

	RelinquishOwnershipCompleted(aError);

	}

EXPORT_C TInt CCallBase::Service(const RMessage2& aMessage,CReqEntry* aReqEntry)

//

// The ServiceL functionality for the call

//

	{

	__ASSERT_ALWAYS(aReqEntry!=NULL,Fault(EEtelFaultCallTsyServiceWithoutReqPackage));

	aReqEntry->iPlacedRequest=ETrue;

	TTsyReqHandle tsyReqHandle=aReqEntry->iTsyReqHandle;

	TDes8* des1 = BufferDes1(aReqEntry->iBuffer,CBuffer::ESlotWrite);

	TUint8* ptr1=Ptr1(des1);

	switch (aReqEntry->iFunction)

		{

	// Asynchronous + Cancel

	case EEtelCallCapsChangeNotification:

		__ASSERT_ALWAYS(des1!=NULL,Fault(EETelFaultRequestWithoutBuffer));

		return NotifyCapsChange(tsyReqHandle,REINTERPRET_CAST(RCall::TCaps*,ptr1));

	case EEtelCallCapsChangeNotificationCancel:

		return NotifyCapsChangeCancel(tsyReqHandle);

	case EEtelCallNotifyHookChange:

		__ASSERT_ALWAYS(des1!=NULL,Fault(EETelFaultRequestWithoutBuffer));

		return NotifyHookChange(tsyReqHandle,REINTERPRET_CAST(RCall::THookStatus*,ptr1));

	case EEtelCallNotifyHookChangeCancel:

		return NotifyHookChangeCancel(tsyReqHandle);

	case EEtelCallNotifyStatusChange:

		__ASSERT_ALWAYS(des1!=NULL,Fault(EETelFaultRequestWithoutBuffer));

		return NotifyStatusChange(tsyReqHandle,REINTERPRET_CAST(RCall::TStatus*,ptr1));

	case EEtelCallNotifyStatusChangeCancel:

		return  NotifyStatusChangeCancel(tsyReqHandle);

	case EEtelCallNotifyDurationChange:

		return NotifyDurationChange(tsyReqHandle,REINTERPRET_CAST(TTimeIntervalSeconds*,ptr1));

	case EEtelCallNotifyDurationChangeCancel:

		return NotifyDurationChangeCancel(tsyReqHandle);

	case EEtelCallDial:

		{

		__ASSERT_ALWAYS(des1!=NULL,Fault(EETelFaultRequestWithoutBuffer));

		TDes* des2 = NULL;

		des2 = BufferDes2u(aReqEntry->iBuffer,CBuffer::ESlotWrite);

		__ASSERT_ALWAYS(des2!=NULL,Fault(EEtelFaultDes2DoesNotExist));

		return Dial(tsyReqHandle,des1,des2);

		}

	case EEtelCallDialCancel:

		return DialCancel(tsyReqHandle);

	case EEtelCallConnect:

		return Connect(tsyReqHandle,des1);

	case EEtelCallConnectCancel:

		return ConnectCancel(tsyReqHandle);

	case EEtelCallAnswer:

		return AnswerIncomingCall(tsyReqHandle,des1);

	case EEtelCallAnswerCancel:

		return AnswerIncomingCallCancel(tsyReqHandle);

	case EEtelCallHangUp:

		return HangUp(tsyReqHandle);

	case EEtelCallHangUpCancel:

		return HangUpCancel(tsyReqHandle);

	case EEtelCallAcquireOwnership:

		{

		if (RCall::EOwnershipOwnedByThisClient==

			CheckOwnershipBySession(aReqEntry->iSession,aMessage.Int3()))

			return KErrEtelAlreadyCallOwner;

		else

			return AcquireOwnership(tsyReqHandle);

		}

	case EEtelCallAcquireOwnershipCancel:

		return AcquireOwnershipCancel(tsyReqHandle);

	// Synchronous

	case EEtelCallGetInfo:

		__ASSERT_ALWAYS(des1!=NULL,Fault(EETelFaultRequestWithoutBuffer));

		return GetInfo(tsyReqHandle,REINTERPRET_CAST(RCall::TCallInfo*,ptr1));

	case EEtelCallGetStatus:

		__ASSERT_ALWAYS(des1!=NULL,Fault(EETelFaultRequestWithoutBuffer));

		return GetStatus(tsyReqHandle,REINTERPRET_CAST(RCall::TStatus*,ptr1));

	case EEtelCallGetCaps:

		__ASSERT_ALWAYS(des1!=NULL,Fault(EETelFaultRequestWithoutBuffer));

		return GetCaps(tsyReqHandle,REINTERPRET_CAST(RCall::TCaps*,ptr1));

	case EEtelCallLoanDataPort:

		{

		__ASSERT_ALWAYS(des1!=NULL,Fault(EETelFaultRequestWithoutBuffer));

		TInt ret=LoanDataPort(tsyReqHandle,REINTERPRET_CAST(RCall::TCommPort*,ptr1));

		if (ret==KErrNone)

			iLoanDataPort=ETrue;

		return ret;

		}

	case EEtelCallLoanDataPortCancel:

		return LoanDataPortCancel(tsyReqHandle);

	case EEtelCallRecoverDataPort:

		{

		TInt ret=RecoverDataPort(tsyReqHandle);

		if (ret==KErrNone)

			iLoanDataPort=EFalse;

		return ret;

		}

	case EEtelCallTransferOwnership:

		return TransferOwnership(tsyReqHandle);

	case EEtelCallGetBearerServiceInfo:

		__ASSERT_ALWAYS(des1!=NULL,Fault(EETelFaultRequestWithoutBuffer));

		return GetBearerServiceInfo(tsyReqHandle,REINTERPRET_CAST(RCall::TBearerService*,ptr1));

	case EEtelCallGetOwnershipStatus:

		{

		__ASSERT_ALWAYS(des1!=NULL,Fault(EETelFaultRequestWithoutBuffer));

		RCall::TOwnershipStatus* owner=REINTERPRET_CAST(RCall::TOwnershipStatus*,ptr1);

		*owner=CheckOwnershipBySession(aReqEntry->iSession,aMessage.Int3());

		ReqCompleted(tsyReqHandle,KErrNone);

		return KErrNone;

		}

	case EEtelCallGetCallParams:

		{

		__ASSERT_ALWAYS(des1!=NULL,Fault(EETelFaultRequestWithoutBuffer));

		return GetCallParams(tsyReqHandle,des1);

		}

	case EEtelCallGetCallDuration:

		{

		__ASSERT_ALWAYS(des1!=NULL,Fault(EETelFaultRequestWithoutBuffer));

		return GetCallDuration(tsyReqHandle,REINTERPRET_CAST(TTimeIntervalSeconds*,ptr1));

		}

	case EEtelCallGetFaxSettings:

		{

		__ASSERT_ALWAYS(des1!=NULL,Fault(EETelFaultRequestWithoutBuffer));

		return GetFaxSettings(tsyReqHandle,REINTERPRET_CAST(RCall::TFaxSessionSettings*,ptr1));

		}

	case EEtelCallSetFaxSettings:

		{

		__ASSERT_ALWAYS(des1!=NULL,Fault(EETelFaultRequestWithoutBuffer));

		return SetFaxSettings(tsyReqHandle,REINTERPRET_CAST(RCall::TFaxSessionSettings*,ptr1));

		}

	case EEtelCallReferenceCount:

 		{

 		__ASSERT_ALWAYS(des1!=NULL,Fault(EETelFaultRequestWithoutBuffer));

 		TInt* count=REINTERPRET_CAST(TInt*,ptr1);

 		*count=AccessCount();

 		ReqCompleted(tsyReqHandle,KErrNone);

 		return KErrNone;

 		}

 	case EEtelAdoptFaxSharedHeaderFile:

		{

		CFaxSharedFileHandles* fshare = NULL;

		TRAPD(err, fshare = CFaxSharedFileHandles::NewL(aMessage));

		if(err != KErrNone)

			{

			return err;	

			}

		//Pass the CFaxSharedFileHandles object to the TSY.  If call is successful then TSY assumes owenership of the object else we delete it.	

		TInt ret = SetFaxSharedHeaderFile(tsyReqHandle, fshare);

		if(ret!= KErrNone)

			{

			delete fshare;	

			}			

		return ret;	

		}

	default:

		return ServiceExtFunc(aMessage,aReqEntry);

		}