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

//

/**

 @file

*/

#include "ET_SSTD.H"

#include "et_record.h"

#include "et_phone_util.h"

//

// CReqEntry class definitions

//

CReqEntry* CReqEntry::NewL(TTsyReqHandle aTsyReqHandle, const RMessage2& aMessage, CTelSession* aSession, CBuffer* aBuffer, const CTelObject* aTelObject, TInt aFunction, RHeap* aHeap)

//

//	Create new request entry.  aHeap should be NULL unless this is to be allocated on the 

//	priority client heap.

//

	{

	if (aHeap != NULL)

		{

		return new(aHeap) CReqEntry(aTsyReqHandle,aMessage,aSession,aBuffer,aTelObject,aFunction,aHeap);

		}

	return new(ELeave) CReqEntry(aTsyReqHandle,aMessage,aSession,aBuffer,aTelObject,aFunction,NULL);

	}

CReqEntry::CReqEntry(TTsyReqHandle aTsyReqHandle,const RMessage2& aMessage,CTelSession* aSession,CBuffer* aBuffer,const CTelObject* aTelObject,TInt aFunction,RHeap* aHeap)

//

//	CReqEntry constructor

//

	: iTsyReqHandle(aTsyReqHandle), iMessage(aMessage), iSession(aSession), iTelObject(aTelObject),

	iClientInterested(ETrue), iCancelFnCalled(EFalse), iFunction(aFunction), iBuffer(aBuffer), 

	iReadByClient(ETrue), iMessageNulled(EFalse), iHeap(aHeap)

	{}

CReqEntry::~CReqEntry()

//

//	CReqEntry destructor

//

	{

	delete iBuffer;

	}

void CReqEntry::Deque()

//

//	Deque CReqEntry list

//

	{

	iLink.Deque();

	iLink.iPrev=iLink.iNext=NULL;

	}

void CReqEntry::CompleteAndDeque(TInt aError)

	{

	// if client does not interested in this request do not completed

	if (iClientInterested) 

		{		

		RECORD_COMPLETE_SUB(iMessage.Session(), iTelObject, iMessage.Int3(), iMessage.Function(), aError);

		iMessage.Complete(aError);

		}

	iLink.Deque();

	}

TAny* CReqEntry::operator new(TUint aSize,RHeap* aHeap) __NO_THROW

//

// overloaded new using the priority client heap - can leave

//

	{

	TAny *pM=NULL;

	TRAPD(err, pM=aHeap->AllocL(aSize) );

	if(err!=KErrNone)

		pM = NULL;

	else

		Mem::FillZ(pM,aSize);

	return(pM);

	}

TAny* CReqEntry::operator new(TUint aSize) __NO_THROW

	{

	return CBase::operator new(aSize);

	}

TAny* CReqEntry::operator new(TUint aSize,TLeave aLeave)

	{

	return CBase::operator new(aSize,aLeave);

	}

TAny* CReqEntry::operator new(TUint aSize,TUint aExtraSize) __NO_THROW

	{

	return CBase::operator new(aSize,aExtraSize);

	}

void CReqEntry::operator delete(TAny* aPtr)

//

// overloaded delete - deletes from priority client heap if iHeap is not NULL

//

	{

	if (((CReqEntry*)aPtr)->iHeap!=NULL)

		((CReqEntry*)aPtr)->iHeap->Free(aPtr);

	else

		User::Free(aPtr);

	}

//

//	CBuffer class definitions

//

CBuffer* CBuffer::NewL(HEtelBufC8* aBuf8,HEtelBufC16* aBuf16,RHeap* aHeap,TInt aSizeOfData1,TInt aSizeOfData2,TInt aNoOfSlots)

	{

	if (aHeap!=NULL)

		return new(aHeap) CBuffer(aBuf8,aBuf16,aHeap,aSizeOfData1,aSizeOfData2,aNoOfSlots);

	return new(ELeave) CBuffer(aBuf8,aBuf16,NULL,aSizeOfData1,aSizeOfData2,aNoOfSlots);

	}

CBuffer::CBuffer(HEtelBufC8* aBuf8,HEtelBufC16* aBuf16,RHeap* aHeap,TInt aSizeOfData1,TInt aSizeOfData2,TInt aNoOfSlots)

	: iBuf8(aBuf8),iBuf16(aBuf16),iHeap(aHeap),iRead(0),iWrite(0),iNoOfSlots(aNoOfSlots),

		iSizeOfData1(aSizeOfData1),iSizeOfData2(aSizeOfData2),

		iOverFlow(EFalse),iBufferFull(EFalse)

	{}

CBuffer::~CBuffer()

	{

	delete iBuf8;

	delete iBuf16;

	}

TAny* CBuffer::operator new(TUint aSize,RHeap* aHeap) __NO_THROW

//

// overloaded new using the priority client heap - can leave

//

	{

	TAny *pM=NULL;

	TRAPD(err, pM=aHeap->AllocL(aSize) );

	if(err!=KErrNone)

		pM = NULL;

	else

		Mem::FillZ(pM,aSize);

	return(pM);

	}

TAny* CBuffer::operator new(TUint aSize) __NO_THROW

	{

	return CBase::operator new(aSize);

	}

TAny* CBuffer::operator new(TUint aSize,TLeave aLeave)

	{

	return CBase::operator new(aSize,aLeave);

	}

TAny* CBuffer::operator new(TUint aSize,TUint aExtraSize) __NO_THROW

	{

	return CBase::operator new(aSize,aExtraSize);

	}

void CBuffer::operator delete(TAny* aPtr)

//

// overloaded delete - deletes from priority client heap if iHeap not NULL

//

	{

	if (((CBuffer*)aPtr)->iHeap!=NULL)

		((CBuffer*)aPtr)->iHeap->Free(aPtr);

	else

		User::Free(aPtr);

	}

TUint CBuffer::Size() const

	{

	return iSizeOfData1 + iSizeOfData2;

	}

void CBuffer::IncRead()

	{

	if(++iRead==iNoOfSlots)

		iRead=0;

	iOverFlow=EFalse;

	iBufferFull=EFalse;

	}

void CBuffer::IncWrite()

	{

	if(++iWrite==iNoOfSlots)

		iWrite=0;

	if (iOverFlow)

		 iRead=iWrite;

	else

		{

		if (!iBufferFull)

			{

			if (iWrite==iRead)

				iBufferFull=ETrue;

			}

		else

			{

			iRead=iWrite;

			iOverFlow=ETrue;

			}

		}

	}

TUint8* CBuffer::CurrentSlotData1(TWhichSlot aWhichSlot) const

//

// iSizeOfData1 and iSizeOfData2 include the sizes of the TPtr's

//

	{

	TInt pos=((aWhichSlot==ESlotRead) ? iRead : iWrite);

	if (iBuf8==NULL)

		{

		return NULL;

		}

	else if (iBuf16==NULL)

		{

		TInt slotSize = iSizeOfData1 + iSizeOfData2;

		return (const_cast<TUint8*> (iBuf8->Des().Mid(pos*(slotSize),iSizeOfData1-sizeof(TPtr8)).Ptr()));

		}

	else

		{

		// we have a narrow and a unicode parameter. Data1 is always narrow

		return (const_cast<TUint8*> (iBuf8->Des().Mid(pos*iSizeOfData1,iSizeOfData1-sizeof(TPtr8)).Ptr()));

		}

	}

TUint8* CBuffer::CurrentSlotData2(TWhichSlot aWhichSlot) const

	{

	if (iSizeOfData2==0)

		return NULL;

	TInt pos=((aWhichSlot==ESlotRead) ? iRead : iWrite);

	if (iBuf8!=NULL  &&  iBuf16==NULL)

		{

		TInt slotSize = iSizeOfData1 + iSizeOfData2;

		return (const_cast<TUint8*> (iBuf8->Des().Mid(pos*(slotSize)+iSizeOfData1,iSizeOfData2-sizeof(TPtr8)).Ptr()));

		}

	return NULL;

	}

TUint16* CBuffer::CurrentSlotData1u(TWhichSlot aWhichSlot) const

//

// Unicode version

//

	{

	TInt pos=((aWhichSlot==ESlotRead) ? iRead : iWrite);

	if (iBuf8==NULL  &&  iBuf16!=NULL)

		{

		TInt slotSize = iSizeOfData1 + iSizeOfData2;

		return (const_cast<TUint16*> (iBuf16->Des().Mid(pos*(slotSize),iSizeOfData1-sizeof(TPtr16)).Ptr()));

		}

	return NULL;	// Data1 will be narrow if we have a mixture of both 8 and 16 bit

	}

TUint16* CBuffer::CurrentSlotData2u(TWhichSlot aWhichSlot) const

//

// Unicode version

//

	{

	if (iSizeOfData2==0)

		return NULL;

	TInt pos=((aWhichSlot==ESlotRead) ? iRead : iWrite);

	if (iBuf16==NULL)

		{

		return NULL;

		}

	else if (iBuf8==NULL)

		{

		TInt slotSize = iSizeOfData1 + iSizeOfData2;

		return (const_cast<TUint16*> (iBuf16->Des().Mid(pos*(slotSize)+iSizeOfData1,iSizeOfData2-sizeof(TPtr16)).Ptr()));

		}

	else

		{

		// we have a narrow and a unicode parameter. Data2 is always unicode

		return (const_cast<TUint16*> (iBuf16->Des().Mid(pos*iSizeOfData2,iSizeOfData2-sizeof(TPtr16)).Ptr()));

		}

	}

TBool CBuffer::EqualSizes(TInt aSize1, TInt aSize2) const

    {

    if(iSizeOfData1 != aSize1)

        {

        return EFalse;

        }

    if(iSizeOfData2 != aSize2)

        {

        return EFalse;

        }

    return ETrue;

    }

TInt CBuffer::CompareRWPtrs() const

	{

	return (iRead-iWrite);

	}

//

//

// CTelObject class definitions

//

EXPORT_C CTelObject::CTelObject()

//

// CTelObject constructor

//

	:iActiveReqCount(0), iTelServer(NULL), iDestroyDummySubSession(NULL), iCreateDummy(EFalse)

	{

	__DECLARE_NAME(_S("CTelObject"));

	}

EXPORT_C CTelObject::~CTelObject()

//

// Destructor

//

	{

	delete iDestroyDummySubSession;

	}

EXPORT_C void CTelObject::CTelObject_Reserved1()

//

// Reserved virtual function

//

	{}

void CTelObject::CreateDummySessionObjectL(CTelSession* aTelSession)

	{

	if (iDestroyDummySubSession==NULL)

		{

		iDestroyDummySubSession = CDestroyDummySubSession::NewL(aTelSession->TelServer(),this);

		}

	else

		{

		}

	}

void CTelObject::CreateDummySession(CTelSession* aSession, const TInt aSubSessionHandle, TBool aCreateDummy)

//

// So the server has to create a dummy session just to keep session alive until completed

// function is called.

//

	{

	iCreateDummy=aCreateDummy;

	if (iDestroyDummySubSession->iOpen == EFalse)

		{

		if ( IsActiveReq(aSession,aSubSessionHandle) || aCreateDummy)

			{

			__ASSERT_ALWAYS(aSession!=NULL,Fault(EEtelFaultBadTelSessionPointer));

			CObject* theObj=this;

			while(theObj->Owner())

				{

				theObj->Open();

				theObj=theObj->Owner();

				}

			theObj->Open();

			iTelServer=aSession->TelServer();

			// incrementing the server's session count to include the dummy session, which

			// has been previously allocated upon the CTelObject creation (by calling

			// CreateDummySessionObjectL() )

			iTelServer->Inc();

			iDestroyDummySubSession->iTelServer = iTelServer;

			iDestroyDummySubSession->iTelObject = this;

			iDestroyDummySubSession->iOpen = ETrue;

			}

		}

	}

void CTelObject::TelObjectClose()

//

// Perform an iterative close of Tel Objects

//

	{	

	CTelObject* owner = reinterpret_cast<CTelObject*> (Owner());

	Close();

	if(owner)

		owner->TelObjectClose();

	}

void CTelObject::CompleteAndDestroyReq(CReqEntry* aReqEntry,const TInt aStatus) const

//

//	complete the entry and remove from entry list and associate heap

//

	{

	if (!aReqEntry->iMessageNulled)

		{

		RECORD_COMPLETE_SUB(aReqEntry->iMessage.Session(), this, aReqEntry->iMessage.Int3(), aReqEntry->iMessage.Function(), aStatus);

		aReqEntry->iMessage.Complete(aStatus);

		}

	DestroyReq(aReqEntry);

	}

void CTelObject::DestroyReq(CReqEntry* aReqEntry) const

//

//	remove from entry list and associate heap

//

	{

	aReqEntry->Deque();

	delete aReqEntry;

	}

TBool CTelObject::IsActiveReq(CTelSession* aSession,const TInt aSubSessionHandle)

//

// Return True if found the active req still out standing

// going through and counting the total of active req

//

	{

	TBool ret=EFalse;

	CReqEntry* reqEntry=NULL;

	TDblQueIter<CReqEntry> iter(PhoneOwner()->ReqActiveList());

	while(reqEntry=iter++,reqEntry!=NULL) // go through the list from begin to end

		{

		if (aSession==reqEntry->iSession && aSubSessionHandle==reqEntry->iMessage.Int3() &&	reqEntry->iClientInterested )

			{

			iActiveReqCount++;

			ret=ETrue;

			}

		}

	return ret;

	}

void CTelObject::CancelActiveReq(CTelSession* aSession,const TInt aSubSessionHandle)

//

// active list - must inform tsy by calling CancelService

// this request will be destroyed when Tsy do an up call ReqCompleted with KErrCancel

// Only go through the list once set the count to zero at start to count number of requests 

//

	{

	CReqEntry* reqEntry=NULL;

	TDblQueIter<CReqEntry> iter(PhoneOwner()->ReqActiveList());

	while(reqEntry=iter++,reqEntry!=NULL) // go through the list from begin to end

		{

		if (aSession==reqEntry->iSession && aSubSessionHandle==reqEntry->iMessage.Int3() &&	reqEntry->iClientInterested )

			{

			reqEntry->iClientInterested=EFalse;

			__ASSERT_ALWAYS(iActiveReqCount>=0,Fault(EEtelFaultNegativeActiveReqCount));

			if (reqEntry->iCancelFnCalled==FALSE)

				{

				if (reqEntry->iPlacedRequest)

					{

					reqEntry->iCancelFnCalled=ETrue;

					CancelService(reqEntry->iFunction,reqEntry->iTsyReqHandle);

					//

					// In calling CancelService() it is possible that a second

					// handle has performed the same request (e.g. a notify) and

					// that ETel will re-post the notify using that handle. In

					// some cases it could happen that the re-posted notify is

					// invalid and fails, thereby completing that next request.

					// Finally, if that request is the next one after this one,

					// then the iterator is going to be invalid. So reset it now

					// and start at the beginning of the list!

					//

					if (PhoneOwner()->ReqActiveList().IsEmpty() == EFalse)

						{

						iter.Set(*PhoneOwner()->ReqActiveList().First());

						}

					else

						{

						break;

						}

					}

				else

					{

					DestroyReq(reqEntry);

					CheckAndDestroyDummySubSession();

					}

				}

			}

		}

	}

void CTelObject::CancelSubSession(CTelSession* aSession,const TInt aSubSessionHandle)

//

// Flush outstanding requests from the queue for this client only

// Cancel the service if request already passed to Tsy

//

	{

	CReqEntry* reqEntry=NULL;

	while (reqEntry=PhoneOwner()->FindClientReqInWaitList(aSession,aSubSessionHandle),reqEntry)

		CompleteAndDestroyReq(reqEntry,KErrCancel);

	CancelActiveReq(aSession,aSubSessionHandle);

	}