// SessionWriter.cpp

// 

// Copyright (c) 2008 - 2010 Accenture. All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the "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:

// Accenture - Initial contribution

//

#include "SessionWriter.h"

#include "cliserv.h"

#include "CloggerServer.h"

CSession2* CSessionWriterServer::NewSessionL(const TVersion& /*aVersion*/, const RMessage2& /*aMessage*/) const

	{

	return new(ELeave) CSessionWriterSession();

	}

CSessionWriterServer::CSessionWriterServer(CCloggerServer& aCloggerServer)

	: CServer2(CActive::EPriorityHigh, ESharableSessions), iCloggerServer(aCloggerServer)

	{

	}

void CSessionWriterServer::ConstructL()

	{

	StartL(KSessionLogServer);

	}

CSessionWriterServer& CSessionWriterSession::Server()

	{

	return *static_cast<CSessionWriterServer*>(const_cast<CServer2*>(CSession2::Server()));

	}

void CSessionWriterSession::ServiceL(const RMessage2 &aMessage)

	{

	TInt res = KErrNone;

	TBool handled = ETrue;

	switch (aMessage.Function())

		{

		case ERegisterForLogMessages:

			{

			if (iSessionWriter)

				{

				// We're already registered

				res = KErrAlreadyExists;

				break;

				}

			CSessionWriter* writer = Server().CloggerServer().RegisterSessionWithSessionWriter(this);

			if (!writer)

				{

				// Only one session can be registered at once, and some other session is

				res = KErrInUse;

				break;

				}

			iSessionWriter = writer;

			RChunk& bufChunk = Server().CloggerServer().GetBufChunk();

			aMessage.Complete(bufChunk);

			return; // As we've handled it ourself

			}

		case EGetNextLog:

			{

			if (!iSessionWriterMessage.IsNull())

				{

				res = KErrAlreadyExists;

				break;

				}

			if (!iSessionWriter)

				{

				PanicClient(aMessage, ENotRegisteredForLogs);

				return;

				}

			iClientSharedChunkBase = (TAny*)aMessage.Ptr1();

			iSessionWriter->SetEnabled(ETrue);

			iSessionWriterMessage = aMessage;

			if (iWaitingForClient)

				{

				iWaitingForClient = EFalse;

				iSessionWriter->Completed();

				}

			return; // Don't want to complete this yet!

			}

		case ECancelGetNextLog:

			if (iSessionWriter)

				{

				iSessionWriter->SetEnabled(EFalse);

				}

			if (!iSessionWriterMessage.IsNull())

				{

				iSessionWriterMessage.Complete(KErrCancel);

				}

			break;

		default:

			handled = EFalse;

		}

	if (handled)

		{

		aMessage.Complete(res);

		}

	else

		{

		PanicClient(aMessage, EPanicIllegalFunction);

		}

	}

void CSessionWriterSession::WriteBuffer(const TDesC8& aBuf)

	{

	const TUint8* ptr = aBuf.Ptr();

	const TUint8* base = Server().CloggerServer().GetBufChunk().Base();

	const TUint8* clientDataPtr = (const TUint8*)((TInt)iClientSharedChunkBase + (TInt)(ptr - base));

	TPtrC8 clientPtr(clientDataPtr, aBuf.Length());

	TPckg<TPtrC8> ptrBuf(clientPtr);

	iWaitingForClient = ETrue;

	TInt err = iSessionWriterMessage.Write(0, ptrBuf);

	iSessionWriterMessage.Complete(err);

	}

TBool CSessionWriterSession::WaitingForClient()

	{

	return iWaitingForClient;

	}

CSessionWriterSession::~CSessionWriterSession()

	{

	if (iSessionWriter)

		{

		Server().CloggerServer().RegisterSessionWithSessionWriter(NULL);

		}

	}

//////////////////////////////

CSessionWriter::CSessionWriter(CCloggerServer& aServer)

	: iServer(aServer)

	{

	}

void CSessionWriter::WriteBuf(TInt aBuf)

	{

	ASSERT(!IsBusyWriting() && iEnabled && iSession);

		{

		iBuf = aBuf;

		const TDesC8& buf = iServer.GetBuf(aBuf);

		iSession->WriteBuffer(buf);

		}

	}

TBool CSessionWriter::IsBusyWriting()

	{

	return iSession && iSession->WaitingForClient();

	}

CSessionWriter::~CSessionWriter()

	{

	}

void CSessionWriter::CloseWriter()

	{

	delete this;

	}

void CSessionWriter::SetEnabled(TBool aEnabled)

	{

	if (!iSession)

		{

		// If there's no session, we can't enable ourselves even if someone asks us to

		aEnabled = EFalse;

		}

	iEnabled = aEnabled;

	if (IsBusyWriting() && !aEnabled)

		{

		// Need to say we've completed this buffer

		iServer.CompletedWritingBuf(this, iBuf);

		}

	}

void CSessionWriter::Completed()

	{

	iServer.CompletedWritingBuf(this, iBuf);

	}