// Copyright (c) 1997-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:

//

#include "../DSTD/DSTD.H"

#include "../DSTD/ACQUIRE.H"

#include "../DSTD/DACQDEF.H"

#include <e32def.h>

#include <f32file.h>

void TsyPanic(TTsyPanic aPanic)

//

// Panic in tsy

//

	{

	_LIT(KTsyPanic,"Tsy Panic");

	User::Panic(KTsyPanic,aPanic);

	}

TTsyTimer::TTsyTimer()

	{

	iPending=EFalse;

	}

//

// CAcquireEntry class

//

CAcquireEntry* CAcquireEntry::NewL(const TTsyReqHandle aTsyReqHandle)

//

//	Create new request entry

//

	{

	return new(ELeave) CAcquireEntry(aTsyReqHandle);

	}

CAcquireEntry::CAcquireEntry(const TTsyReqHandle aTsyReqHandle)

//

//	 constructor

//

	{

	iTsyReqHandle=aTsyReqHandle;

	}

CAcquireEntry::~CAcquireEntry()

//

//	destructor

//

	{}

void CAcquireEntry::Deque()

//

//	Deque  list

//

	{

	iLink.Deque();

	iLink.iPrev=iLink.iNext=NULL;

	}

CAcquireOwnerList::CAcquireOwnerList()

	{}

CAcquireOwnerList::~CAcquireOwnerList()

	{}

CAcquireOwnerList* CAcquireOwnerList::NewL()

//

//	Static function to create new call

//

	{

	CAcquireOwnerList* ac=new(ELeave) CAcquireOwnerList();

	CleanupStack::PushL(ac);

	ac->ConstructL();

	CleanupStack::Pop();

	return ac;

	}

void CAcquireOwnerList::ConstructL()

	{

	iAcquireList.SetOffset(_FOFF(CAcquireEntry,iLink));

	}

CAcquireEntry* CAcquireOwnerList::FindByTsyReqHandle(const TTsyReqHandle aTsyReqHandle)

	{

	CAcquireEntry* entry;

	TDblQueIter<CAcquireEntry> iter(iAcquireList);

	while(entry = iter++, entry!=NULL)

		{

		if(entry->iTsyReqHandle==aTsyReqHandle)

			return entry;

		}

	return NULL;

	}

void CAcquireOwnerList::Remove(CAcquireEntry* aEntry)

	{

	aEntry->Deque();

	delete aEntry;

	}

//

// CFaxDummyBase

//

CFaxDummyBase::CFaxDummyBase(CPhoneFactoryDummyBase* aFac)

	{

	iFac=aFac;

	}

CFaxDummyBase::~CFaxDummyBase()

	{

	iFac->RemoveTimer(iRead);

	iFac->RemoveTimer(iWrite);

	iFac->RemoveTimer(iWaitForEndOfPage);

	iFac->RemoveTimer(iProgressNotification);

	}

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

	{

	return KErrNone;

	}

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

	{

	return KErrNone;

	}

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

//

//	mode request for fax

//

	{

	CTelObject::TReqMode ret=0;

	switch (aIpc)

		{

	case EEtelFaxTerminateFaxSession:

	case EEtelFaxWaitForEndOfPage:

		break;

	case EEtelFaxRead:

	case EEtelFaxWrite:

		ret=KReqModeFlowControlObeyed;

		break;

	default:

		User::Leave(KErrNotSupported);

		break;

		}

	return ret;

	}

CFaxDummyBase* CFaxDummyBase::This(TAny* aPtr)

	{

	return REINTERPRET_CAST(CFaxDummyBase*,aPtr);

	}

TInt CFaxDummyBase::WaitForEndOfPageHandler(TAny* aPtr)

//

//	Completed	req

//

	{

	This(aPtr)->iFac->ResetPending( This(aPtr)->iWaitForEndOfPage);

	This(aPtr)->ReqCompleted(This(aPtr)->iWaitForEndOfPage.iTsyReqHandle,KErrNone);

	return KErrNone;

	}

TInt CFaxDummyBase::WaitForEndOfPage(const TTsyReqHandle aTsyReqHandle)

	{

	iFac->QueueTimer(iWaitForEndOfPage,aTsyReqHandle,DACQ_ASYN_TIMEOUT,CFaxDummyBase::WaitForEndOfPageHandler,this);

	return KErrNone;

	}

TInt CFaxDummyBase::Read(const TTsyReqHandle aTsyReqHandle,TDes8* aDes)

//

//	Fax	read

//

	{

	iReadParams=aDes;

	iFac->QueueTimer(iRead,aTsyReqHandle,DACQ_ASYN_TIMEOUT,CFaxDummyBase::ReadHandler,this);

	return KErrNone;

	}

TInt CFaxDummyBase::ReadHandler(TAny* aPtr)

//

//	Completed Request

//

	{

	This(aPtr)->iReadParams->Copy(DACQ_FAX_BUF_DATA);

	This(aPtr)->iFac->ResetPending( This(aPtr)->iRead);

	This(aPtr)->ReqCompleted(This(aPtr)->iRead.iTsyReqHandle,KErrNone);

	return KErrNone;

	}

TInt CFaxDummyBase::TerminateFaxSession(const TTsyReqHandle aTsyReqHandle)

	{

	if (iFac->RemoveTimer(iRead))

		ReqCompleted(iRead.iTsyReqHandle,KErrCancel);

	if (iFac->RemoveTimer(iWrite))

		ReqCompleted(iWrite.iTsyReqHandle,KErrCancel);

	if (iFac->RemoveTimer(iWaitForEndOfPage))

		ReqCompleted(iWaitForEndOfPage.iTsyReqHandle,KErrCancel);

//	if (iFac->RemoveTimer(iProgressNotification))

//		ReqCompleted(iProgressNotification.iTsyReqHandle,KErrCancel);

	ReqCompleted(aTsyReqHandle,KErrNone);

	return KErrNone;

	}

TInt CFaxDummyBase::Write(const TTsyReqHandle aTsyReqHandle,TDesC8* aDes)

	{

	if (aDes->Compare(DACQ_FAX_BUF_DATA)!=KErrNone)

		TsyPanic(KTsyPanicDataCorrupted);

	iFac->QueueTimer(iWrite,aTsyReqHandle,DACQ_ASYN_TIMEOUT,CFaxDummyBase::WriteHandler,this);

	return KErrNone;

	}

TInt CFaxDummyBase::WriteHandler(TAny* aPtr)

	{

	This(aPtr)->iFac->ResetPending( This(aPtr)->iWrite);

	This(aPtr)->ReqCompleted(This(aPtr)->iWrite.iTsyReqHandle,KErrNone);

	return KErrNone;

	}

TInt CFaxDummyBase::GetProgress(const TTsyReqHandle aTsyReqHandle,RFax::TProgress* aProgress)

	{

	aProgress->iSpeed=DACQ_GET_PROGRESS_SPEED;

	ReqCompleted(aTsyReqHandle,KErrNone);

	return KErrNone;

	}

TInt CFaxDummyBase::ProgressNotificationHandler(TAny* aPtr)

	{

	This(aPtr)->iFac->ResetPending( This(aPtr)->iProgressNotification);

	This(aPtr)->ReqCompleted(This(aPtr)->iProgressNotification.iTsyReqHandle,KErrNone);

	return KErrNone;

	}

TInt CFaxDummyBase::ProgressNotification(const TTsyReqHandle aTsyReqHandle, RFax::TProgress* aProgress)

	{

	iProgressNotificationParams=aProgress;

	iFac->QueueTimer(iProgressNotification,aTsyReqHandle,DACQ_ASYN_TIMEOUT,CFaxDummyBase::ProgressNotificationHandler,this);

	return KErrNone;

	}

TInt CFaxDummyBase::ProgressNotificationCancel(const TTsyReqHandle aTsyReqHandle)

	{

	if(aTsyReqHandle==iProgressNotification.iTsyReqHandle)

		{

		iFac->RemoveTimer(iProgressNotification);

		ReqCompleted(aTsyReqHandle,KErrCancel);

		return KErrNone;

		}

	TsyPanic(KTsyPanicNotRecognisedCancelHandle);

	return KErrNone;

	}

//

// CCallDummyBase

//

CCallDummyBase::CCallDummyBase(CPhoneFactoryDummyBase* aFac)

	{

	iFac=aFac;

	}

void CCallDummyBase::ConstructL()

	{

	iList=CAcquireOwnerList::NewL();

	}

CCallDummyBase::~CCallDummyBase()

	{

	delete iList;

	iFac->RemoveTimer(iNotifyHookChange);

	iFac->RemoveTimer(iNotifyStatusChange);

	iFac->RemoveTimer(iDial);

	iFac->RemoveTimer(iConnect);

	iFac->RemoveTimer(iAnswer);

	iFac->RemoveTimer(iHangUp);

	}

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

	{

	return KErrNone;

	}

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

	{

	return KErrNone;

	}

CCallDummyBase* CCallDummyBase::This(TAny* aPtr)

	{

	return REINTERPRET_CAST(CCallDummyBase*,aPtr);

	}

CPhoneFactoryDummyBase* CCallDummyBase::FacPtr() const

	{

	return iFac;

	}

TInt CCallDummyBase::CancelSubSession()

	{

	return KErrNone;

	}

TInt CCallDummyBase::ProcessingOwnership()

	{

	if (iList)

		{	

		if(iList->iAcquireList.IsEmpty()) // no one interested in this call !

			{

			SetUnowned();

			return KErrNone;

			}

		CAcquireEntry* entry=iList->iAcquireList.First();

		if (entry) // someone interested in this call

			{

			SetOwnership(entry->iTsyReqHandle);

			ReqCompleted(entry->iTsyReqHandle,KErrNone);

			iList->Remove(entry);

			}

		return KErrNone;

		}

	else

		return KErrNotFound;

	}

TInt CCallDummyBase::RelinquishOwnership()

	{

	ProcessingOwnership();

	RelinquishOwnershipCompleted(KErrNone);

	return KErrNone;

	}

TInt CCallDummyBase::TransferOwnership(const TTsyReqHandle aTsyReqHandle)

//

//	Transfer Call Ownership

//

	{

	if (CheckOwnership(aTsyReqHandle)!=CCallBase::EOwnedTrue)

		{

		ReqCompleted(aTsyReqHandle,KErrEtelNotCallOwner);

		return KErrNone;

		}

	if(iList->iAcquireList.IsEmpty()) // no one interested in this call !

		{

		ReqCompleted(aTsyReqHandle,KErrEtelNoClientInterestedInThisCall);

		return KErrNone;

		}

	CAcquireEntry* entry=iList->iAcquireList.First();

	if (entry) // someone interested in this call

		{

		SetOwnership(entry->iTsyReqHandle);

		ReqCompleted(entry->iTsyReqHandle,KErrNone);

		iList->Remove(entry);

		ReqCompleted(aTsyReqHandle,KErrNone);

		}

	return KErrNone;

	}

TInt CCallDummyBase::AcquireOwnership(const TTsyReqHandle aTsyReqHandle)

//

//	Acquire call Ownership

//

	{

	TInt ret(KErrNone);

	if (CheckOwnership(aTsyReqHandle)==CCallBase::EOwnedUnowned)

		{

		SetOwnership(aTsyReqHandle);

		ReqCompleted(aTsyReqHandle,KErrNone);

		}

	else

		{

		if(iList->iAcquireList.IsEmpty())

			// List is empty. Client is the first one to request ownership of the call.

			{

			CAcquireEntry* entry=NULL;

			TRAP(ret, entry=CAcquireEntry::NewL(aTsyReqHandle));

			if (ret==KErrNone)

				iList->iAcquireList.AddLast(*entry);

			}

		else

			// List is not empty. Another client has already requested to acquire ownership of the call.

			// Only one client can be waiting to acquire ownership at any one time.

			return KErrInUse;

		}

	return ret;

	}

TInt CCallDummyBase::AcquireOwnershipCancel(const TTsyReqHandle aTsyReqHandle)

//

//	Cancel Acquire Call Ownership

//

	{

	CAcquireEntry* entry=iList->FindByTsyReqHandle(aTsyReqHandle);

	if (entry)

		{

		ReqCompleted(entry->iTsyReqHandle,KErrCancel);

		iList->Remove(entry);

		}

	ReqCompleted(aTsyReqHandle,KErrNone);

	return KErrNone;

	}

TInt CCallDummyBase::NotifyCapsChangeHandler(TAny* aPtr)

	{

	This(aPtr)->iFac->ResetPending( This(aPtr)->iNotifyCapsChange);

	This(aPtr)->ReqCompleted(This(aPtr)->iNotifyCapsChange.iTsyReqHandle,KErrNone);

	return KErrNone;

	}

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

	{

	iFac->QueueTimer(iNotifyCapsChange,aTsyReqHandle,DACQ_ASYN_TIMEOUT,

						CCallDummyBase::NotifyCapsChangeHandler,this);

	return KErrNone;

	}

TInt CCallDummyBase::NotifyCapsChangeCancel(const TTsyReqHandle aTsyReqHandle)

	{

	if (aTsyReqHandle==iNotifyCapsChange.iTsyReqHandle)

		{

		iFac->RemoveTimer(iNotifyCapsChange);

		ReqCompleted(aTsyReqHandle,KErrCancel);

		return KErrNone;

		}

	TsyPanic(KTsyPanicNotRecognisedCancelHandle);

	return KErrNone;

	}

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

	{

	iNotifyHookChangeParams=aHookStatus;

	iFac->QueueTimer(iNotifyHookChange,aTsyReqHandle,DACQ_ASYN_TIMEOUT,

						CCallDummyBase::NotifyHookChangeHandler,this);

	return KErrNone;

	}

TInt CCallDummyBase::NotifyHookChangeCancel(const TTsyReqHandle aTsyReqHandle)

	{

	if (aTsyReqHandle==iNotifyHookChange.iTsyReqHandle)

		{

		iFac->RemoveTimer(iNotifyHookChange);

		ReqCompleted(aTsyReqHandle,KErrCancel);

		return KErrNone;

		}

	TsyPanic(KTsyPanicNotRecognisedCancelHandle);

	return KErrNone;

	}

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

	{

	iNotifyStatusChangeParams=aStatus;

	iFac->QueueTimer(iNotifyStatusChange,aTsyReqHandle,DACQ_ASYN_TIMEOUT,

						CCallDummyBase::NotifyStatusChangeHandler,this);

	return KErrNone;

	}

TInt CCallDummyBase::NotifyStatusChangeCancel(const TTsyReqHandle aTsyReqHandle)

	{

	if (aTsyReqHandle==iNotifyStatusChange.iTsyReqHandle)

		{

		iFac->RemoveTimer(iNotifyStatusChange);

		ReqCompleted(aTsyReqHandle,KErrCancel);

		return KErrNone;

		}

	TsyPanic(KTsyPanicNotRecognisedCancelHandle);

	return KErrNone;

	}

TInt CCallDummyBase::NotifyDurationChange(const TTsyReqHandle aTsyReqHandle,TTimeIntervalSeconds*)

	{

	iFac->QueueTimer(iNotifyDurationChange,aTsyReqHandle,DACQ_ASYN_TIMEOUT,

						CCallDummyBase::NotifyDurationChangeHandler,this);

	return KErrNone;

	}

TInt CCallDummyBase::NotifyDurationChangeCancel(const TTsyReqHandle aTsyReqHandle)

	{

	if (aTsyReqHandle==iNotifyDurationChange.iTsyReqHandle)

		{

		iFac->RemoveTimer(iNotifyDurationChange);

		ReqCompleted(aTsyReqHandle,KErrCancel);