// client.cpp

// 

// Copyright (c) 2009 - 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 <consoleproxy.h>

#include "server.h"

//______________________________________________________________________________

//						RConsoleProxy

static TInt StartServer(const TDesC& aServerName, const TDesC& aServerArgs)

	{

	TPtrC processName(aServerName);

	if (processName.Length() && processName[0] == '!')

		{

		processName.Set(processName.Mid(1));

		}

	RProcess server;

	TInt r = server.Create(processName, aServerArgs);

	if (r!=KErrNone) return r;

	TRequestStatus stat;

	server.Rendezvous(stat);

	if (stat != KRequestPending)

		{

		server.Kill(0);

		}

	else

		{

		server.Resume();

		}

	User::WaitForRequest(stat);		// wait for start or death

	r = (server.ExitType() == EExitPanic) ? KErrGeneral : stat.Int();

	server.Close();

	return r;

	}

EXPORT_C TInt RConsoleProxy::Connect(const TDesC& aServerName, const TDesC& aServerArgs)

	{

	TInt retry = 2;

	for (;;)

		{

		TInt r = CreateSession(aServerName, TVersion(0,0,0));

		if ((r != KErrNotFound) && (r != KErrServerTerminated))

			{

			return r;

			}

		if (--retry == 0)

			{

			return r;

			}

		r = StartServer(aServerName, aServerArgs);

		if ((r != KErrNone) && (r != KErrAlreadyExists))

			{

			return r;

			}

		}

	}

EXPORT_C TInt RConsoleProxy::Connect(RServer2 aServer)

	{

	return CreateSession(aServer, TVersion(0,0,0));

	}

EXPORT_C TInt RConsoleProxy::Connect(TConsoleCreateFunction aConsoleCreate, const TDesC& aThreadNameBase, TInt aStackSize, TInt aHeapMinSize, TInt aHeapMaxSize, RServer2& aServer, RThread& aServerThread)

	{

	TConsoleProxyServerNewLParams newLParams(KNullDesC, CActive::EPriorityStandard, aConsoleCreate);

	TServerParams params;

	params.iServerNewL = &CConsoleProxyServer::NewL;

	params.iServerParams = &newLParams;

	return DoConnect(&params, aThreadNameBase, aStackSize, aHeapMinSize, aHeapMaxSize, aServer, aServerThread);

	}

EXPORT_C TInt RConsoleProxy::Connect(TServerNewL aServerConstructor, TAny* aServerParams, const TDesC& aThreadNameBase, TInt aStackSize, TInt aHeapMinSize, TInt aHeapMaxSize, RServer2& aServer, RThread& aServerThread)

	{

	TServerParams params;

	params.iServerNewL = aServerConstructor;

	params.iServerParams = aServerParams;

	return DoConnect(&params, aThreadNameBase, aStackSize, aHeapMinSize, aHeapMaxSize, aServer, aServerThread);

	}

TInt RConsoleProxy::DoConnect(TServerParams* aParams, const TDesC& aThreadNameBase, TInt aStackSize, TInt aHeapMinSize, TInt aHeapMaxSize, RServer2& aServer, RThread& aServerThread)

	{

	TName threadName;

	RThread server;

	TInt threadId = 0;

	_LIT(KThreadIdFmt, "%08x");

	TInt err;

	do

		{

		threadName = aThreadNameBase.Left(threadName.MaxLength()-8);

		threadName.AppendFormat(KThreadIdFmt, threadId);

		err = server.Create(threadName, &ServerThreadFunction, aStackSize, aHeapMinSize, aHeapMaxSize, aParams);

		++threadId;

		} while (err==KErrAlreadyExists);

	if (err!=KErrNone) return err;

	TRequestStatus rendezvous;

	server.Rendezvous(rendezvous);

	if (rendezvous == KRequestPending)

		{

		server.Resume();

		}

	User::WaitForRequest(rendezvous);

	err = rendezvous.Int();

	if (server.ExitType() != EExitPending && err >= 0) err = KErrDied;

	if (err==KErrNone)

		{

		err = Connect(aParams->iServer);

		}

	aServer = aParams->iServer;

	aServerThread = server;

	return err;

	}

EXPORT_C TInt RConsoleProxy::Server(RServer2& aServer)

	{

	TInt r = SendReceive(EGetServer);

	return aServer.SetReturnedHandle(r);

	}

EXPORT_C void RConsoleProxy::Create(const TDesC& aConsoleTitle, TSize aSize, TRequestStatus& aStatus)

	{

	SendReceive(ECreate, TIpcArgs(&aConsoleTitle, aSize.iWidth, aSize.iHeight), aStatus);

	}

EXPORT_C void RConsoleProxy::Read(TRequestStatus& aStatus)

	{

	SendReceive(ERead, aStatus);

	}

EXPORT_C void RConsoleProxy::Read(TPckg<TKeyCode>& aKeyCode, TPckg<TUint>& aKeyModifiers, TRequestStatus& aStatus)

	{

	SendReceive(EReadKey, TIpcArgs(&aKeyCode, &aKeyModifiers), aStatus);

	}

EXPORT_C void RConsoleProxy::ReadCancel()

	{

	Send(EReadCancel);

	}

EXPORT_C void RConsoleProxy::Write(const TDesC& aDescriptor, TRequestStatus& aStatus)

	{

	SendReceive(EWrite, TIpcArgs(&aDescriptor), aStatus);

	}

EXPORT_C void RConsoleProxy::CursorPos(TPckg<TPoint>& aPos, TRequestStatus& aStatus) const

	{

	SendReceive(EGetCursorPos, TIpcArgs(&aPos), aStatus);

	}

EXPORT_C void RConsoleProxy::SetCursorPosAbs(const TPoint& aPoint, TRequestStatus& aStatus)

	{

	SendReceive(ESetCursorPosAbs, TIpcArgs(aPoint.iX, aPoint.iY), aStatus);

	}

EXPORT_C void RConsoleProxy::SetCursorPosRel(const TPoint& aPoint, TRequestStatus& aStatus)

	{

	SendReceive(ESetCursorPosRel, TIpcArgs(aPoint.iX, aPoint.iY), aStatus);

	}

EXPORT_C void RConsoleProxy::SetCursorHeight(TInt aPercentage, TRequestStatus& aStatus)

	{

	SendReceive(ESetCursorHeight, TIpcArgs(aPercentage), aStatus);

	}

EXPORT_C void RConsoleProxy::SetTitle(const TDesC& aTitle, TRequestStatus& aStatus)

	{

	SendReceive(ESetTitle, TIpcArgs(&aTitle), aStatus);

	}

EXPORT_C void RConsoleProxy::ClearScreen(TRequestStatus& aStatus)

	{

	SendReceive(EClearScreen, aStatus);

	}

EXPORT_C void RConsoleProxy::ClearToEndOfLine(TRequestStatus& aStatus)

	{

	SendReceive(EClearToEndOfLine, aStatus);

	}

EXPORT_C void RConsoleProxy::GetScreenSize(TPckg<TSize>& aSize, TRequestStatus& aStatus) const

	{

	SendReceive(EGetScreenSize, TIpcArgs(&aSize), aStatus);

	}

EXPORT_C void RConsoleProxy::SetAttributes(TUint aAttributes, ConsoleAttributes::TColor aForegroundColor, ConsoleAttributes::TColor aBackgroundColor, TRequestStatus& aStatus)

	{

	SendReceive(ESetAttributes, TIpcArgs(aAttributes, aForegroundColor, aBackgroundColor), aStatus);

	}

EXPORT_C TInt RConsoleProxy::IsConstructed(TBool& aLazy)

	{

	TPckg<TBool> constructed(aLazy);

	return SendReceive(EIsConstructed, TIpcArgs(&constructed));

	}

EXPORT_C TInt RConsoleProxy::GetKeyCode(TKeyCode& aCode) const

	{

	TPckg<TKeyCode> kc(aCode);

	return SendReceive(EGetKeyCode, TIpcArgs(&(kc)));

	}

EXPORT_C TInt RConsoleProxy::GetKeyModifiers(TUint& aModifiers) const

	{

	TPckg<TUint> mod(aModifiers);

	return SendReceive(EGetKeyCode, TIpcArgs(&mod));

	}

EXPORT_C TInt RConsoleProxy::Create(const TDesC& aConsoleTitle, TSize aSize)

	{

	TRequestStatus stat;

	Create(aConsoleTitle, aSize, stat);

	User::WaitForRequest(stat);

	return stat.Int();

	}

EXPORT_C TInt RConsoleProxy::Write(const TDesC& aDescriptor)

	{

	TRequestStatus stat;

	Write(aDescriptor, stat);

	User::WaitForRequest(stat);

	return stat.Int();

	}

EXPORT_C TInt RConsoleProxy::CursorPos(TPoint& aPos) const

	{

	TRequestStatus stat;

	TPckg<TPoint> pos(aPos);

	CursorPos(pos, stat);

	User::WaitForRequest(stat);

	return stat.Int();

	}

EXPORT_C TInt RConsoleProxy::SetCursorPosAbs(const TPoint& aPoint)

	{

	TRequestStatus stat;

	SetCursorPosAbs(aPoint, stat);

	User::WaitForRequest(stat);

	return stat.Int();

	}

EXPORT_C TInt RConsoleProxy::SetCursorPosRel(const TPoint& aPoint)

	{

	TRequestStatus stat;

	SetCursorPosRel(aPoint, stat);

	User::WaitForRequest(stat);

	return stat.Int();

	}

EXPORT_C TInt RConsoleProxy::SetCursorHeight(TInt aPercentage)

	{

	TRequestStatus stat;

	SetCursorHeight(aPercentage, stat);

	User::WaitForRequest(stat);

	return stat.Int();

	}

EXPORT_C TInt RConsoleProxy::SetTitle(const TDesC& aTitle)

	{

	TRequestStatus stat;

	SetTitle(aTitle, stat);

	User::WaitForRequest(stat);

	return stat.Int();

	}

EXPORT_C TInt RConsoleProxy::ClearScreen()

	{

	TRequestStatus stat;

	ClearScreen(stat);

	User::WaitForRequest(stat);

	return stat.Int();

	}

EXPORT_C TInt RConsoleProxy::ClearToEndOfLine()

	{

	TRequestStatus stat;

	ClearToEndOfLine(stat);

	User::WaitForRequest(stat);

	return stat.Int();

	}

EXPORT_C TInt RConsoleProxy::GetScreenSize(TSize& aSize) const

	{

	TRequestStatus stat;

	TPckg<TSize> size(aSize);

	GetScreenSize(size, stat);

	User::WaitForRequest(stat);

	return stat.Int();

	}

//______________________________________________________________________________

//						CConsoleProxy

EXPORT_C CConsoleProxy* CConsoleProxy::NewL(const RConsoleProxy& aProxySession)

	{

	CConsoleProxy* self = new(ELeave)CConsoleProxy();

	CleanupStack::PushL(self);

	self->ConstructL(aProxySession);

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CConsoleProxy::CConsoleProxy()

	: iKeyCodePckg(iKeyCode), iKeyModifiersPckg(iKeyModifiers)

	{

	}

EXPORT_C TInt CConsoleProxy::Extension_(TUint aExtensionId, TAny*& a0, TAny* a1)

	{

	if (aExtensionId == ConsoleAttributes::KSetConsoleAttributesExtension)

		{

		TRequestStatus status;

		ConsoleAttributes::TAttributes* attributes = (ConsoleAttributes::TAttributes*)a1;

		iConsole.SetAttributes(attributes->iAttributes, attributes->iForegroundColor, attributes->iBackgroundColor, status);

		User::WaitForRequest(status);

		return status.Int();

		}

	if (aExtensionId == LazyConsole::KLazyConsoleExtension)

		{

		TBool* constructed = (TBool*)a1;

		return iConsole.IsConstructed(*constructed);

		}

	return CConsoleBase::Extension_(aExtensionId, a0, a1);

	}

EXPORT_C void CConsoleProxy::ConstructL(const RConsoleProxy& aProxySession)

	{

	RConsoleProxy cons = aProxySession;

	User::LeaveIfError(cons.Duplicate(RThread(), EOwnerThread));

	iConsole = cons;

	}

EXPORT_C CConsoleProxy::~CConsoleProxy()

	{

	iConsole.Close();

	}

EXPORT_C TInt CConsoleProxy::Create(const TDesC &aTitle, TSize aSize)

	{

	return iConsole.Create(aTitle, aSize);

	}

EXPORT_C void CConsoleProxy::Read(TRequestStatus &aStatus)

	{

	iConsole.Read(iKeyCodePckg, iKeyModifiersPckg, aStatus);

	}

EXPORT_C void CConsoleProxy::ReadCancel()

	{

	iConsole.ReadCancel();

	}

EXPORT_C void CConsoleProxy::Write(const TDesC &aDes)

	{

	iConsole.Write(aDes);

	}

EXPORT_C TPoint CConsoleProxy::CursorPos() const

	{

	TPoint pos;

	iConsole.CursorPos(pos);

	return pos;

	}

EXPORT_C void CConsoleProxy::SetCursorPosAbs(const TPoint &aPoint)

	{

	iConsole.SetCursorPosAbs(aPoint);

	}

EXPORT_C void CConsoleProxy::SetCursorPosRel(const TPoint &aPoint)

	{

	iConsole.SetCursorPosRel(aPoint);

	}

EXPORT_C void CConsoleProxy::SetCursorHeight(TInt aPercentage)

	{

	iConsole.SetCursorHeight(aPercentage);

	}

EXPORT_C void CConsoleProxy::SetTitle(const TDesC &aTitle)

	{

	iConsole.SetTitle(aTitle);

	}

EXPORT_C void CConsoleProxy::ClearScreen()

	{

	iConsole.ClearScreen();

	}

EXPORT_C void CConsoleProxy::ClearToEndOfLine()

	{

	iConsole.ClearToEndOfLine();

	}

EXPORT_C TSize CConsoleProxy::ScreenSize() const

	{

	TSize size;

	iConsole.GetScreenSize(size);

	return size;

	}

EXPORT_C TKeyCode CConsoleProxy::KeyCode() const

	{

	return iKeyCode;

	}

EXPORT_C TUint CConsoleProxy::KeyModifiers() const

	{

	return iKeyModifiers;

	}