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

// RWsBuffer class, handles buffering and flushing of window server commands

// 

//

#include <e32std.h>

#include "../SERVER/w32cmd.h"

#include "CLIENT.H"

#include "w32comm.h"

// Global functions

GLDEF_C void Assert(TW32Assert aAssert)

	{

	_LIT(KW32AssertCategory,"W32 Assert");

	User::Panic(KW32AssertCategory,aAssert);

	}

GLDEF_C void Panic(TW32Panic aPanic)

	{

	_LIT(KW32PanicCategory,"W32");

	User::Panic(KW32PanicCategory,aPanic);

	}

// Public functions

RWsBuffer::RWsBuffer(RWsSession *aSession) : iSession(aSession), iManager(NULL),

	#if defined(__AUTO_FLUSH)

		iAutoFlush(ETrue),

	#else

		iAutoFlush(EFalse),

	#endif

	iBuf(NULL,0,0), iNext(NULL), iPreviousHandle(0), iBufSize(0), iMaxBufSize(EMinBufferSize),

	#if defined(_DEBUG)

	iAppendDataLength(0),

	#endif

	iDirectAcessCount(0), iInvalidBitmapArray(EFalse), iWindowSizeCache(NULL)

	{

	}

TInt WsFbsDestroyCallBack(TAny* aBitmapHandle)

	{

	TInt* bitmapHandle=static_cast<TInt*>(aBitmapHandle);

	RWsBuffer::FlushAllBuffers(aBitmapHandle ? *bitmapHandle : 0);

	return(0);

	}

void RWsBuffer::SetCallBack()

	{

	for(RWsBuffer *buffer=(RWsBuffer *)Dll::Tls();buffer;buffer=buffer->iNext)

		if (buffer==this)

			return;	// Already linked

	iNext=(RWsBuffer *)Dll::Tls();

	Dll::SetTls(this);

	if (iNext==NULL)	// First connection so set callback

		RFbsSession::GetSession()->SetCallBack(TCallBack(WsFbsDestroyCallBack,NULL));

	}

void RWsBuffer::CancelCallBack()

	{

	RWsBuffer *buffer=(RWsBuffer *)Dll::Tls();

	if (buffer==this)

		{

		Dll::SetTls(iNext);

		if (iNext==NULL)

			RFbsSession::GetSession()->ResetCallBack();	// Last connection closing so cancel the callback

		}

	else

		{

		RWsBuffer *prev;

		while(buffer)

			{

			prev=buffer;

			buffer=buffer->iNext;

			if (buffer==this)

				{

				prev->iNext=iNext;

				break;

				}

			}

		}

	}

void RWsBuffer::Close()

	{

	User::Free((TAny *)iBuf.Ptr());

	if (iWindowSizeCache)

	    {

	    iWindowSizeCache->Close();

	    delete iWindowSizeCache;

	    iWindowSizeCache = NULL;

	    }

	}

void RWsBuffer::Destroy()

	{

	Flush();

	Close();

	delete this;

	}

TInt RWsBuffer::Flush(const TIpcArgs* aIpcArgs,TBool aRequestFinish)

	{

	iBitmapArray.Reset();

	iInvalidBitmapArray=EFalse;

	if (iBuf.Length()==0)

		{

		return(KErrNone);

		}

	TIpcArgs ipcArgs;

	if (aIpcArgs!=NULL)

		{

		ipcArgs=*aIpcArgs;

		// check that the caller hasn't used the first slot

		ipcArgs.Set(KBufferMessageSlot,TIpcArgs::ENothing);

		__ASSERT_ALWAYS(Mem::Compare(REINTERPRET_CAST(const TUint8*, &ipcArgs), sizeof(TIpcArgs), REINTERPRET_CAST(const TUint8*, aIpcArgs), sizeof(TIpcArgs))==0,Panic(EW32PanicUsingReservedIpcSlot));

		}

	ipcArgs.Set(KBufferMessageSlot,&iBuf);

	TInt ret;

	if(aRequestFinish)

		ret=iSession->DoFlush(ipcArgs);

	else

		ret=iSession->DoSyncMsgBuf(ipcArgs);

	iBuf.Zero();

	iPreviousHandle=0;

	return(ret);

	}

void RWsBuffer::FlushAllBuffers(TInt aBitmapHandle)

	{

	for(RWsBuffer *buffer=(RWsBuffer *)Dll::Tls();buffer;buffer=buffer->iNext)

		{

		if(!aBitmapHandle || buffer->iInvalidBitmapArray || (buffer->iBitmapArray.FindInOrder(aBitmapHandle)!=KErrNotFound))

			buffer->Flush();

		}

	}

inline void RWsBuffer::SetAndLimitMaxBufSize(TInt aMaxBufSize)

	{ // apply upper & lower limits to input buffer size

	if (aMaxBufSize < EMinBufferSize)

		{

		iMaxBufSize = EMinBufferSize;

		}

	else if	(aMaxBufSize > EMaxBufferSize)

		{

		iMaxBufSize = EMaxBufferSize;

		}

	else

		{

		iMaxBufSize = aMaxBufSize;

		}

	}

void RWsBuffer::SetBufferSizeL(TInt aBufSize)

	{

	SetAndLimitMaxBufSize(aBufSize);

	ReAllocBufferL(iMaxBufSize);

	}

void RWsBuffer::SetMaxBufferSizeL(TInt aMaxBufSize)

	{

	SetAndLimitMaxBufSize(aMaxBufSize);

	if (iMaxBufSize < iBufSize)

		{ // shrink to new maximum

		ReAllocBufferL(iMaxBufSize);

		}

	else

		{

		 // initial allocation should be (at least) a quarter of the requested size

		TInt minSize = Max( (iMaxBufSize + 3) >> 2, EMinBufferSize);

		if (minSize > iBufSize)

			{ // new or enlarged buffer

			ReAllocBufferL(minSize);

			}

		}

	__ASSERT_DEBUG((iBufSize >= EMinBufferSize) && (iBufSize <= iMaxBufSize), Assert(EW32AssertBufferLogic));

	}

// Flush() buffer, try to ReAlloc, Leave if the ReAlloc fails.

void RWsBuffer::ReAllocBufferL(TInt aNewSize)

	{

	if (aNewSize != iBufSize)

		{

		Flush();

		if (!ReAllocBuffer(aNewSize))

			{

			User::LeaveNoMemory();

			}

		}

	}

TBool RWsBuffer::ReAllocBuffer(TInt aNewSize)

	{

	TUint8* ptr = const_cast<TUint8*>(iBuf.Ptr());

	__ASSERT_DEBUG((iBufSize == 0) || (ptr != NULL), Assert(EW32AssertBufferLogic));

	const TInt len = iBuf.Length();

	TUint8* newPtr = static_cast<TUint8*>(User::ReAlloc(ptr, aNewSize));

	if (newPtr != NULL)

		{ // realloc was successful

		iBuf.Set(newPtr, len, aNewSize);

		iBufSize = aNewSize;

		return ETrue;

		}

	return EFalse;

	}

/* Expand the buffer, to allow new drawing command to fit.

 Called either when trying to store additional commands to queue for Wserv, or

 the trying to send a command bigger than the current buffer size.

 Failure to expand the buffer is a minor problem in the first case but a big 

 problem in the second.

 @param aRequiredSpace Size of buffer increase required.

 @param aMsgSize If expanding the buffer fails then needs this value to know whether Flush() is good enough.

 @return ETrue if there is enough space, EFalse if not.

 */

void RWsBuffer::GrowBuffer(TInt aRequiredSpace, TInt aMsgSize)

	{

	__ASSERT_DEBUG(iBufSize < iMaxBufSize, Assert(EW32AssertBufferLogic));

	// maximum size will be big enough?

	__ASSERT_ALWAYS(aMsgSize <= iMaxBufSize, Panic(EW32PanicDataExceedsBufferLength));

	 // double or quad the current size, then limit it

	TInt newSize = Min((iBufSize >= aRequiredSpace) ? iBufSize << 1 : iBufSize << 2, iMaxBufSize);

	if (!ReAllocBuffer(newSize))

		{ // OOM error

		Flush();

		if (aMsgSize > iBufSize)

			{ // message is too big for buffer

			Panic(EW32PanicDataExceedsBufferLength);

			}

		}

	}

TBool RWsBuffer::SetAutoFlush(TBool aState)

	{

	TBool old;

	old=iAutoFlush;

#if defined(__AUTO_FLUSH)

	if (aState)

#else

	iAutoFlush=aState;

	if (iAutoFlush)

#endif

		Flush();

	return(old);

	}

TInt RWsBuffer::DoWrite(TInt aHandle, TUint aOpcode, TBool aFlush, const TIpcArgs* aIpcArgs, const TAny* aData, TInt aLength, const TAny* aData2, TInt aLength2)

	{

	__ASSERT_DEBUG(((TUint32) aOpcode) < 0x8000, Assert(EW32AssertIllegalOpcode));

	__ASSERT_DEBUG((aLength&0x3) == 0, Assert(EW32AssertOddLengthData));

	TInt xtra(0);

	if (aLength2>0)

		xtra = PadValue(aLength2);		// Round data upto a multiple of 4

	const TInt msgSize = aLength + aLength2 + xtra + static_cast<TInt>(sizeof(TWsCmdHeader));

	TInt available = iBuf.MaxLength() - iBuf.Length();

	if (msgSize > available)

		{

		if (iBufSize >= iMaxBufSize)

			{ // buffer is maximum size already

			Flush();

			}

		else

			{ // try to grow buffer

			 if ( (iBuf.Length() + msgSize) > iMaxBufSize)

				{ // growing alone will not make enough extra space

				Flush();

				available = iBufSize;

				}

			const TInt requiredSpace = msgSize - available;

			if (requiredSpace > 0)

				{

				GrowBuffer(requiredSpace, msgSize);

				}

			}

		}

	TWsCmdHeader cmdHeader;

	cmdHeader.iBase.iOpcode = (TInt16)aOpcode;

	cmdHeader.iBase.iCmdLength = (TInt16)(aLength + aLength2 + xtra);

	// For performance reasons we only pass in the handle if it is different

	// from the previous command

	if (aHandle == iPreviousHandle)

		{

		iBuf.Append((TUint8 *)&cmdHeader.iBase,sizeof(cmdHeader.iBase));

		}

	else

		{

		iPreviousHandle = aHandle;

		cmdHeader.iBase.iOpcode|=EWsOpcodeHandle;

		cmdHeader.iDestHandle = aHandle;

		iBuf.Append((TUint8 *)&cmdHeader,sizeof(cmdHeader));

		}

	if (aLength)

		{

		iBuf.Append((TUint8 *)aData, aLength);

		}

	if (aLength2>0 && aData2!=NULL)

		{

		iBuf.Append((TUint8 *)aData2, aLength2);

		iBuf.AppendFill(0,xtra);

		}

#if defined(_DEBUG)

	else if (aLength2>0 && aData2==NULL)

		{

		iAppendDataLength = aLength2;

		}

#endif

	if (aFlush)

		{

		return Flush(aIpcArgs);

		}

	return KErrNone;

	}

void RWsBuffer::Write(TInt handle,TUint opcode)

	{

	DoWrite(handle, opcode, iAutoFlush, NULL);

	}

/**

Writes data sent in aData of length aLength1 for the specifed aOpcode

into wserv buffer. It also takes an TIpcArgs by which you can send additional 

data. But one thing needs to be noted that if aIpcArgs has some content then 

this function flushes the wserv buffer.

@param aHandle aHandle of class derived from MWsClientClass

@param aOpcode Opcode for the current command

@param aData Data to be added to the buffer

@param aLength Length of the data to be added to buffer

@param aIpcArgs Additional data sent from client to server. It has default argument NULL.

				And if some data is sent in aIpcArgs, it flushes wserv buffer

*/

void RWsBuffer::Write(TInt aHandle, TUint aOpcode, const TAny *aData, TInt aLength, const TIpcArgs* aIpcArgs/*=NULL*/)

	{

	TBool flush = (aIpcArgs != NULL ? ETrue : iAutoFlush);	// If aIpcArgs contains data then we do explicit flush

	DoWrite(aHandle, aOpcode, flush, aIpcArgs, aData, aLength);

	}

/**

Writes data sent in aData and aData2 of lengths aLength1 and aLength2 

for the specifed aOpcode into wserv buffer. It also takes an TIpcArgs by which 

you can send additional data. But one thing needs to be noted that if aIpcArgs 

has some content then this function flushes the wserv buffer.

@param aHandle Handle of class derived from MWsClientClass

@param aOpcode Opcode for the current command

@param aData Data to be added to the buffer

@param aLength Length of the data to be added to buffer

@param aData2 second Data to be added to the buffer

@param aLength2 Length of the second data to be added to buffer

@param aIpcArgs Additional data sent from client to server. It has default argument NULL.

				And if some data is sent in aIpcArgs, it flushes wserv buffer

*/

void RWsBuffer::Write(TInt aHandle, TUint aOpcode, const TAny *aData, TInt aLength, const TAny *aData2, TInt aLength2, const TIpcArgs* aIpcArgs/*=NULL*/)

	{

	__ASSERT_DEBUG(!((aIpcArgs != NULL) &&  (aLength2 > 0 && aData2 == NULL)), Assert(EW32AssertBufferLogic));

	TBool flush = iAutoFlush;

	if (aLength2 > 0 && aData2 == NULL)

		{

		flush = EFalse;		// if just length2 is sent then we should not flush

		}

	else if (aIpcArgs != NULL)

		{

		flush = ETrue;		// If aIpcArgs contains data then we do explicit flush

		}

	DoWrite(aHandle, aOpcode, flush, aIpcArgs, aData, aLength, aData2, aLength2);

	}

/**

Appends data directly to wserv buffer for the current command. So this function 

should be used after adding the current command. 

@param aData Data to be added to the buffer

@param aLength Length of the data to be added to buffer. Make sure that its length

		is less than availabe buffer.

@param aFinished EFalse, adds data to buffer and disables flushing even if auto flush is on, 

				 basically this notfies that more data is pending to be added.

				 ETrue, adds data to buffer and resume normal service for flushing

				 ie. Signals that this is the last bit of data to be added

Note: When data is added using this API, it pads out buffer to multiple of 4 bytes  

*/

void RWsBuffer::AppendData(const TAny *aData,TInt aLength,TBool aFinished)

	{

	__ASSERT_ALWAYS(iBuf.MaxLength()-iBuf.Length()>=PaddedValue(aLength),Assert(EW32AssertBufferLogic));

#if defined(_DEBUG)

	// Check if this function is called only after setting iAppendDataLength

	__ASSERT_DEBUG(iAppendDataLength > 0, Assert(EW32AssertBufferLogic));

	// Check if length passed in is less then iAppendDataLength

	__ASSERT_DEBUG(iAppendDataLength >= aLength, Assert(EW32AssertBufferLogic));

	if (aFinished)

		iAppendDataLength = 0; 

	else

		iAppendDataLength -= aLength;

#endif

	iBuf.Append((TUint8*)(aData),aLength);

	iBuf.AppendFill(0,PadValue(iBuf.Length()));		// Padout out buffer to multiple of 4 bytes

	if (aFinished && iAutoFlush)

		Flush(NULL);

	}

TInt RWsBuffer::WriteReply(TInt handle,TUint opcode,const TIpcArgs* aIpcArgs)

	{

	return DoWrite(handle, opcode, ETrue, aIpcArgs);

	}

TInt RWsBuffer::WriteReply(TInt handle,TUint opcode,const TAny *pData, TInt length,const TIpcArgs* aIpcArgs)

	{

	return DoWrite(handle, opcode, ETrue, aIpcArgs, pData, length);

	}

TInt RWsBuffer::WriteReply(TInt handle,TUint opcode,const TAny *pData,TInt length,const TAny *pData2,TInt length2,const TIpcArgs* aIpcArgs)

	{

	return DoWrite(handle, opcode, ETrue, aIpcArgs, pData, length, pData2, length2);

	}

TInt RWsBuffer::WriteReplyP(TInt aHandle, TUint aOpcode, const TWriteDescriptorType& aReplyBuffer)

	{

	TIpcArgs ipcArgs;

	aReplyBuffer.SetDescriptorOnIpcArgs(ipcArgs);

	return DoWrite(aHandle, aOpcode, ETrue, &ipcArgs);

	}

TInt RWsBuffer::WriteReplyP(TInt aHandle,TUint aOpcode,const TAny *aData,TInt aLength,const TWriteDescriptorType& aReplyBuffer)

	{

	TIpcArgs ipcArgs;

	aReplyBuffer.SetDescriptorOnIpcArgs(ipcArgs);

	return DoWrite(aHandle, aOpcode, ETrue, &ipcArgs, aData, aLength);

	}

TInt RWsBuffer::WriteReplyP(TInt aHandle,TUint aOpcode,const TAny *aData1,TInt aLengthData1,const TAny *aData2,TInt aLengthData2,const TWriteDescriptorType& aReplyBuffer)

	{

	TIpcArgs ipcArgs;

	aReplyBuffer.SetDescriptorOnIpcArgs(ipcArgs);

	return DoWrite(aHandle, aOpcode, ETrue, &ipcArgs, aData1, aLengthData1, aData2, aLengthData2);

	}

TInt RWsBuffer::WriteReplyWs(TUint opcode)

//

// Do a WriteReply using the sessions handle

//

	{

	return(iSession->WriteReply(opcode));

	}

TInt RWsBuffer::WriteReplyWs(const TAny *pData, TInt aLength, TUint aOpcode)

//

// Do a WriteReply using the sessions handle

//

	{

	return(iSession->WriteReply(pData,aLength,aOpcode));

	}

TInt RWsBuffer::WriteReplyWs(const TAny *pData, TInt aLength, const TAny *pData2, TInt aLength2, TUint aOpcode)

//

// Do a WriteReply using the sessions handle

//

	{

	return(iSession->WriteReply(pData,aLength,pData2,aLength2,aOpcode));

	}

TInt RWsBuffer::WriteReplyByProvidingRemoteReadAccess(TInt aHandle,TUint aOpcode,const TAny *aData, TInt aLength,const TReadDescriptorType& aRemoteReadBuffer)

	{

	TIpcArgs ipcArgs;

	aRemoteReadBuffer.SetDescriptorOnIpcArgs(ipcArgs);

	return DoWrite(aHandle, aOpcode, ETrue, &ipcArgs, aData, aLength);

	}

void RWsBuffer::AddToBitmapArray(TInt aBitmapHandle)

	{

	if(aBitmapHandle && !iInvalidBitmapArray)

		{

		if(iBitmapArray.InsertInOrder(aBitmapHandle)==KErrNoMemory)

			iInvalidBitmapArray=ETrue;

		}

	}

void RWsBuffer::SetWsGraphicManager(CWsGraphic::CManager* aManager)

	{

	__ASSERT_DEBUG(!WsGraphicManager(),Panic(EW32PanicGraphicInternal));

	iManager = aManager;

	}

CWsGraphic::CManager* RWsBuffer::WsGraphicManager()

	{

	for(RWsBuffer *buffer=(RWsBuffer *)Dll::Tls();buffer;buffer=buffer->iNext)

		if (buffer->iManager)

			return buffer->iManager;	

	return NULL; // does not yet exist

	}

void RWsBuffer::AsyncRequest(TInt aHandle, TUint aOpcode, TRequestStatus& aStatus)

	{

	aStatus = KRequestPending;

	__ASSERT_DEBUG((aOpcode&EWservMessAsynchronousService)==0, Assert(EW32AssertIllegalOpcode));

	Flush(); 

	const TInt function = EWservMessAsynchronousService | aOpcode;

	TIpcArgs ipcArgs(aHandle);

	iSession->SendReceive(function, ipcArgs, aStatus);

	}

void RWsBuffer::EnableWindowSizeCacheL()

    {

    if (iWindowSizeCache == NULL)

        {

        iWindowSizeCache = new (ELeave) RHashMap<TInt, TWindowSizeCacheEntry>();        

        }

    }