// console.cpp

// 

// Copyright (c) 2006 - 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 <e32cons.h>

#include <e32uid.h>

#include "server.h"

#include "console.h"

#include "log.h"

#ifdef IOSRV_LOGGING

#define CONSOLE_NAME TName consoleName(Name())

#define READER_NAME(x) TName readerName((x).IorName())

#define WRITER_NAME(x) TName writerName((x).IowName())

#else

#define CONSOLE_NAME

#define READER_NAME(x)

#define WRITER_NAME(x)

#endif

const TInt KConsoleThreadMinHeapSize = 0x1000;

const TInt KConsoleThreadMaxHeapSize = 0x1000000;

CIoConsole* CIoConsole::NewLC(const TDesC& aImplementation, const TDesC& aTitle, const TSize& aSize, const TIoConfig& aConfig, CIoConsole* aUnderlying, TUint aOptions)

	{

	CIoConsole* self = new(ELeave) CIoConsole(aConfig);

	CleanupClosePushL(*self);

	self->ConstructL(aImplementation, aTitle, aSize, aUnderlying, aOptions);

	return self;

	}

CIoConsole::~CIoConsole()

	{

	// if the sub-thread is servicing a request of ours now, we have to kill it. Otherwise, we might hang

	// when we try and cancel the request AO, if (for example) it's servicing a long-standing Create request.

	if (iRequestAo && (iRequestAo->IsActive()) && (iServerThread.Handle()!=KNullHandle))

		{

		iServerThread.Kill(KErrCancel);

		iThreadServer.Close(); // this won't be closed by the sub-thread, as we just killed it.

		}

	delete iThreadWatcher;

	delete iRequestAo;

	iRequestQueue.Close();

	delete iImplementation;

	delete iReader;

	iConsole.Close();

	delete iCreationTitle ;

	iServerThread.Close();

	}

const TDesC& CIoConsole::Implementation() const

	{

	return *iImplementation;

	}

TBool CIoConsole::IsType(RIoHandle::TType aType) const

	{

	return ((aType == RIoHandle::EEndPoint) || (aType == RIoHandle::EConsole));

	}

void CIoConsole::HandleReaderDetached(MIoReader& aReader)

	{

	HandleReadWriterDetached(aReader);

	}

void CIoConsole::HandleWriterDetached(MIoWriter& aWriter)

	{

	HandleReadWriterDetached(aWriter);

	}

template <class T> void CIoConsole::HandleReadWriterDetached(T& aReadWriter)

	{

	// Remove pending requests originated from this reader / writer.

	for (TInt i = (iRequestQueue.Count() - 1); i >= 0; --i)

		{

		TConsoleRequest* request = iRequestQueue[i];

		if (request->OriginatedFrom(aReadWriter))

			{

			delete request;

			iRequestQueue.Remove(i);

			}

		}

	// If this reader / writer originated the request that's currently being process, abort it.

	if (iRequestAo->CurrentRequest() && iRequestAo->CurrentRequest()->OriginatedFrom(aReadWriter))

		{

		iRequestAo->Abort();

		}

	}

void CIoConsole::IorepReadL(MIoReader&)

	{

	if (!iReader->IsActive())

		{

		iReader->QueueRead();

		}

	}

void CIoConsole::IorepReadKeyL(MIoReader& aReader)

	{

	IorepReadL(aReader);

	}

void CIoConsole::IorepSetConsoleModeL(RIoReadWriteHandle::TMode aMode, MIoReader& aReader)

	{

	NewRequest(new(ELeave)TConsoleSetModeRequest(aReader, *this, aMode));

	}

void CIoConsole::IowepWriteL(MIoWriter& aWriter)

	{

	NewRequest(new(ELeave)TConsoleWriteRequest(aWriter));

	}

void CIoConsole::IowepWriteCancel(MIoWriter&)

	{

	}

void CIoConsole::IowepCursorPosL(MIoWriter& aWriter) const

	{

	NewRequest(new(ELeave)TConsoleCursorPosRequest(aWriter));

	}

void CIoConsole::IowepSetCursorPosAbsL(const TPoint& aPoint, MIoWriter& aWriter)

	{

	NewRequest(new(ELeave)TConsoleSetCursorPosAbsRequest(aWriter, aPoint));

	}

void CIoConsole::IowepSetCursorPosRelL(const TPoint& aPoint, MIoWriter& aWriter)

	{

	NewRequest(new(ELeave)TConsoleSetCursorPosRelRequest(aWriter, aPoint));

	}

void CIoConsole::IowepSetCursorHeightL(TInt aPercentage, MIoWriter& aWriter)

	{

	NewRequest(new(ELeave)TConsoleSetCursorHeightRequest(aWriter, aPercentage));

	}

void CIoConsole::IowepSetTitleL(MIoWriter& aWriter)

	{

	NewRequest(new(ELeave)TConsoleSetTitleRequest(aWriter));

	}

void CIoConsole::IowepClearScreenL(MIoWriter& aWriter)

	{

	NewRequest(new(ELeave)TConsoleClearScreenRequest(aWriter));

	}

void CIoConsole::IowepClearToEndOfLineL(MIoWriter& aWriter)

	{

	NewRequest(new(ELeave)TConsoleClearToEndOfLineRequest(aWriter));

	}

void CIoConsole::IowepSetAttributesL(TUint aAttributes, ConsoleAttributes::TColor aForegroundColor, ConsoleAttributes::TColor aBackgroundColor, MIoWriter& aWriter)

	{

	NewRequest(new(ELeave)TConsoleSetAttributesRequest(aWriter, aAttributes, aForegroundColor, aBackgroundColor));

	}

void CIoConsole::IowepScreenSizeL(MIoWriter& aWriter) const

	{

	NewRequest(new(ELeave)TConsoleScreenSizeRequest(aWriter, iConfig));

	}

CIoConsole::CIoConsole(const TIoConfig& aConfig)

	: iConfig(aConfig), iDetectedSize(-1, -1)

	{

	}

void CIoConsole::ConstructL(const TDesC& aImplementation, const TDesC& aTitle, const TSize& aSize, CIoConsole* aUnderlying, TUint aOptions)

	{

	LOG(CIoLog::Printf(_L("Console 0x%08x created"), this));

	iCreationTitle = aTitle.AllocL();

	iCreationSize = aSize;

	iRequestAo = new(ELeave)CConsoleRequest(*this);

	if (aImplementation.Length())

		{

		iImplementation = aImplementation.AllocL();

		}

	else

		{

		iImplementation = iConfig.ConsoleImplementation().AllocL();

		}

	User::LeaveIfError(iConsole.Connect(CIoConsoleProxyServerNewL, iImplementation, *iImplementation, KDefaultStackSize, KConsoleThreadMinHeapSize, KConsoleThreadMaxHeapSize, iThreadServer, iServerThread));

	iThreadWatcher = new(ELeave)CServerDeathWatcher(iThreadServer, iServerThread);

	if (aOptions & RIoConsole::ELazyCreate)

		{

		User::LeaveIfError(iConsole.SetLazyConstruct());

		}

	if (iConfig.ConsoleSizeDetect())

		{

		User::LeaveIfError(iConsole.SetConsoleSizeDetect());

		}

	if (aUnderlying)

		{

		User::LeaveIfError(aUnderlying->Open());

		CleanupClosePushL(*aUnderlying);

		NewRequest(new(ELeave)TConsoleSetUnderlyingRequest(*aUnderlying));

		CleanupStack::Pop();

		}

	NewRequest(new(ELeave)TConsoleCreateRequest(*this));

	iReader = CConsoleReader::NewL(*this);

	}

void CIoConsole::CreateComplete(TInt aError)

	{

	iCreateStatus = aError;

	}

void CIoConsole::NewRequest(TConsoleRequest* aRequest) const

	{

	ASSERT(aRequest);

	TInt err = iRequestQueue.Append(aRequest);

	if (err!=KErrNone)

		{

		aRequest->CompleteD(err);

		return;

		}

	CheckQueue();

	}

void CIoConsole::CheckQueue() const

	{

	if (iCreateStatus != KErrNone)

		{

		while (iRequestQueue.Count())

			{

			TConsoleRequest* req = iRequestQueue[0];

			iRequestQueue.Remove(0);

			req->CompleteD(iCreateStatus);

			}

		return;

		}

	if ((!iRequestAo->IsActive()) && (iRequestQueue.Count()))

		{

		iRequestAo->Service(iRequestQueue[0]);

		iRequestQueue.Remove(0);

		}

	}

void CIoConsole::ConsoleDied()

	{

	iCreateStatus = KErrGeneral;

	iReader = CConsoleReader::NewL(*this);

	}

void CIoConsole::ReadComplete(TInt aError)

	{

	MIoReader* foregroundReader = AttachedReader(0);

	if (foregroundReader)

		{

		foregroundReader->IorReadKeyComplete(aError, 0, 0);

		}

	}

void CIoConsole::ReadComplete(TUint aKeyCode, TUint aModifiers)

	{

	TInt index = 0;

	MIoReader* foregroundReader = AttachedReader(index++);

	MIoReader* reader = foregroundReader;

	TBool keyHandled(EFalse);

	while (reader)

		{

		if (reader->IorIsKeyCaptured(aKeyCode, aModifiers))

			{

			if (reader->IorReadPending())

				{

				TPtrC keyCodePtr((TUint16*)&aKeyCode, 1);

				reader->IorReadBuf().Append(keyCodePtr);

				reader->IorDataBuffered(1);

				}

			else

				{

				reader->IorReadKeyComplete(KErrNone, aKeyCode, aModifiers);

				}

			keyHandled = ETrue;

			break;

			}

		reader = AttachedReader(index++);;

		}

	// Key not captured, so send to foreground (i.e. the first) reader.

	if (!keyHandled && foregroundReader)

		{

		foregroundReader->IorReadKeyComplete(KErrNone, aKeyCode, aModifiers);

		}

	QueueReaderIfRequired();

	}

void CIoConsole::QueueReaderIfRequired()

	{

	TBool pendingReader(EFalse);

	TInt index = 0;

	MIoReader* reader = AttachedReader(index++);

	while (reader)

		{

		if (reader->IorReadPending() || reader->IorReadKeyPending())

			{

			pendingReader = ETrue;

			break;

			}

		reader = AttachedReader(index++);

		}

	if (pendingReader && !iReader->IsActive())

		{

		iReader->QueueRead();

		}

	else if (!pendingReader && iReader->IsActive())

		{

		iReader->Cancel();

		}

	}

CIoConsole::CConsoleReader* CIoConsole::CConsoleReader::NewL(CIoConsole& aConsole)

	{

	return new(ELeave) CConsoleReader(aConsole);

	}

CIoConsole::CConsoleReader::~CConsoleReader()

	{

	Cancel();

	}

void CIoConsole::CConsoleReader::QueueRead()

	{

	iConsole.iConsole.Read(iKeyCodePckg, iKeyModifiersPckg, iStatus);

	SetActive();

	}

CIoConsole::CConsoleReader::CConsoleReader(CIoConsole& aConsole)

	: CActive(CActive::EPriorityStandard), iConsole(aConsole)

	, iKeyCodePckg(iKeyCode), iKeyModifiersPckg(iKeyModifiers)

	{

	CActiveScheduler::Add(this);

	}

void CIoConsole::CConsoleReader::RunL()

	{

	TInt err = iStatus.Int();

	if (err==KErrServerTerminated)

		{

		iConsole.ConsoleDied();

		err = KErrGeneral;

		}

	if (err)

		{

		iConsole.ReadComplete(err);

		}

	else

		{

		iConsole.ReadComplete(iKeyCode, iKeyModifiers);

		}

	}

void CIoConsole::CConsoleReader::DoCancel()

	{

	iConsole.iConsole.ReadCancel();

	}

//______________________________________________________________________________

//						TConsoleRequest

void CIoConsole::TConsoleRequest::PrepareL()

	{

	}

TBool CIoConsole::TConsoleRequest::OriginatedFrom(MIoReader&) const

	{ 

	return EFalse; 

	}

TBool CIoConsole::TConsoleRequest::OriginatedFrom(MIoWriter&) const

	{

	return EFalse;

	}

//______________________________________________________________________________

//						TConsoleWriterRequest

CIoConsole::TConsoleWriterRequest::TConsoleWriterRequest(MIoWriter& aWriter)

	: iWriter(aWriter)

	{

	}

TBool CIoConsole::TConsoleWriterRequest::OriginatedFrom(MIoWriter& aWriter) const

	{

	return (&iWriter == &aWriter);

	}

//______________________________________________________________________________

//						TConsoleReaderRequest

CIoConsole::TConsoleReaderRequest::TConsoleReaderRequest(MIoReader& aReader)

	: iReader(aReader)

	{

	}

TBool CIoConsole::TConsoleReaderRequest::OriginatedFrom(MIoReader& aReader) const

	{

	return (&iReader == &aReader);

	}

//______________________________________________________________________________

//						TConsoleCreateRequest

CIoConsole::TConsoleCreateRequest::TConsoleCreateRequest(CIoConsole& aOwner)

	: iOwner(aOwner)

	{

	}

void CIoConsole::TConsoleCreateRequest::Request(RIoConsoleProxy aProxy, TRequestStatus& aStatus)

	{

	aProxy.Create(*iOwner.iCreationTitle, iOwner.iCreationSize, aStatus);

	}

void CIoConsole::TConsoleCreateRequest::CompleteD(TInt aError)

	{

	iOwner.CreateComplete(aError);

	delete this;

	}

//______________________________________________________________________________

//						TConsoleWriteRequest

CIoConsole::TConsoleWriteRequest::TConsoleWriteRequest(MIoWriter& aWriter)

	: TConsoleWriterRequest(aWriter), iBuf(NULL)

	{

	}

void CIoConsole::TConsoleWriteRequest::Request(RIoConsoleProxy aProxy, TRequestStatus& aStatus)

	{

	if (iWriter.IowIsStdErr())

		{

		aProxy.WriteStdErr(*iBuf, aStatus);

		}

	else

		{

		aProxy.Write(*iBuf, aStatus);

		}

	}

void CIoConsole::TConsoleWriteRequest::PrepareL()

	{

	const TInt length = iWriter.IowWriteLength();

	if (iBuf == NULL)

		{

		iBuf = HBufC::NewL(length);

		}

	else if (iBuf->Des().MaxLength() < length)

		{

		iBuf = iBuf->ReAllocL(length);

		}

	TPtr bufPtr(iBuf->Des());

	bufPtr.Zero();

	iWriter.IowWrite(bufPtr);

	if (iWriter.IorwMode() == RIoReadWriteHandle::EText)

		{

		// Fix line endings (change LF to CRLF).

		RArray<TInt> indicies(5);

		CleanupClosePushL(indicies);

		_LIT(KCarriageReturn, "\r");

		for (TInt i = 0; i < length; ++i)

			{

			if ((*iBuf)[i] == '\n')

				{

				if ((i == 0) || ((*iBuf)[i - 1] != '\r'))

					{

					User::LeaveIfError(indicies.Append(i));

					}

				}

			}

		const TInt count = indicies.Count();

		if (count > 0)

			{

			if (bufPtr.MaxLength() < (length + count))

				{

				iBuf = iBuf->ReAllocL(length + count);

				bufPtr.Set(iBuf->Des());

				}

			for (TInt i = (count - 1); i >= 0; --i)

				{

				bufPtr.Insert(indicies[i], KCarriageReturn);

				}

			}

		CleanupStack::PopAndDestroy(&indicies);

		}

	}

void CIoConsole::TConsoleWriteRequest::CompleteD(TInt aError)

	{

	delete iBuf;

	iWriter.IowComplete(aError);

	delete this;

	}

//______________________________________________________________________________

//						TConsoleCursorPosRequest

CIoConsole::TConsoleCursorPosRequest::TConsoleCursorPosRequest(MIoWriter& aWriter)

	: TConsoleWriterRequest(aWriter), iPosPckg(iPos)

	{

	}

void CIoConsole::TConsoleCursorPosRequest::Request(RIoConsoleProxy aProxy, TRequestStatus& aStatus)

	{

	aProxy.CursorPos(iPosPckg, aStatus);

	}

void CIoConsole::TConsoleCursorPosRequest::CompleteD(TInt aError)

	{

	iWriter.IowCursorPos(aError, iPos);

	delete this;

	}

//______________________________________________________________________________

//						TConsoleSetCursorPosAbsRequest