// persistentconsole.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 "persistentconsole.h"

#include <e32hashtab.h>

static void CleanupNullPointer(TAny* aPtrPtr)

	{

	*((TAny**)aPtrPtr) = NULL;

	}

static void CleanupNullPointerPushL(TAny** aPtr)

	{

	CleanupStack::PushL(TCleanupItem(CleanupNullPointer, aPtr));

	}

_LIT(KProxySuffix, "_proxy");

//______________________________________________________________________________

//						CIoPersistentConsole

CIoPersistentConsole* CIoPersistentConsole::NewLC(const TDesC& aName, const TDesC& aTitle, CIoServer& aServer, const RMsg& aMessage)

	{

	CIoPersistentConsole* self = new(ELeave)CIoPersistentConsole(aServer);

	CleanupClosePushL(*self);

	self->ConstructL(aName, aTitle, aMessage);

	return self;

	}

TBool CIoPersistentConsole::CanConnectReaderL(const MIoReadEndPoint& aReader) const

	{

	// check that the candidate end point will not result in a circular connection of

	// persistent consoles if it's connected to this one.

	RHashSet<TInt> chained; // addresses of CIoPersistentConsole's in any chain

	CleanupClosePushL(chained);

	chained.InsertL((TInt)this);

	const MIoReadEndPoint* nextReader = &aReader;

	while (nextReader && nextReader->IoepIsType(RIoHandle::EPersistentConsole))

		{

		const CIoPersistentConsole* next = (const CIoPersistentConsole*)nextReader;

		if (chained.Find((TInt)next))

			{

			CleanupStack::PopAndDestroy();

			return EFalse;

			}

		chained.InsertL((TInt)next);

		nextReader = next->TransientReader();

		}

	CleanupStack::PopAndDestroy();

	return ETrue;	

	}

void CIoPersistentConsole::AttachTransientReaderL(MIoReadEndPoint& aReader, CIoSession* aDetachOnClose)

	{

	if (!CanConnectReaderL(aReader)) User::Leave(KErrCouldNotConnect);	

	if (iTransientReadEndPoint)

		{

		User::Leave(KErrInUse);

		}

	iTransientReadEndPoint = &aReader;

	CleanupNullPointerPushL((TAny**)&iTransientReadEndPoint);

	TInt fgProxyPos = ReaderProxyIndex(AttachedReader());

	if (fgProxyPos != KErrNotFound)

		{

		iTransientReadEndPoint->IorepAttachL(*iReaderProxies[fgProxyPos], RIoEndPoint::EForeground);

		}

	TInt i = 0;

	TRAPD(err, 

		for (i=0; i<iReaderProxies.Count(); ++i)

			{

			if (i != fgProxyPos)

				{

				iTransientReadEndPoint->IorepAttachL(*iReaderProxies[i], RIoEndPoint::EBackground);

				}

			}

		);

	if (err)

		{

		// deatch the readers the we successfully attached before failure

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

			{

			iTransientReadEndPoint->IorepDetach(*iReaderProxies[j]);

			}

		// also make sure that the foreground reader is deatched

		if (fgProxyPos >= i)

			{

			iTransientReadEndPoint->IorepDetach(*iReaderProxies[fgProxyPos]);

			}

		User::Leave(err);

		}

	CleanupStack::Pop();

	iReadEndPointDetachOnClose = aDetachOnClose;

	// now foreward any outstanding read requests

	for (TInt i=0; i<iReaderProxies.Count(); ++i)

		{

		iReaderProxies[i]->TransientReaderAttached(*iTransientReadEndPoint);

		}

	MIoReader* fg = AttachedReader();

	if (fg)

		{

		fg->IorReaderChange(RIoReadHandle::EGainedForeground | RIoReadHandle::EConsoleSizeChanged);

		}

	}

void CIoPersistentConsole::DetachTransientReader()

	{

	if (!iTransientReadEndPoint)

		{

		return;

		}

	MIoReadEndPoint* detaching = iTransientReadEndPoint;

	iTransientReadEndPoint = NULL;

	TInt fgReaderPos = ReaderProxyIndex(AttachedReader());

	for (TInt i=0; i<iReaderProxies.Count(); ++i)

		{

		if (i!=fgReaderPos)

			{

			detaching->IorepDetach(*iReaderProxies[i]);

			}

		}

	if (fgReaderPos!=KErrNotFound)

		{

		detaching->IorepDetach(*iReaderProxies[fgReaderPos]);

		}

	iReadEndPointDetachOnClose = NULL;

	SendReadDetachNotifications();

	}

const MIoReadEndPoint* CIoPersistentConsole::TransientReader() const

	{

	return iTransientReadEndPoint;

	}	

TBool CIoPersistentConsole::CanConnectWriterL(const MIoWriteEndPoint& aWriter) const

	{

	// check that the candidate end point will not result in a circular connection of

	// persistent consoles if it's connected to this one.

	RHashSet<TInt> chained; // addresses of CIoPersistentConsole's in any chain

	CleanupClosePushL(chained);

	chained.InsertL((TInt)this);

	const MIoWriteEndPoint* nextWriter = &aWriter;

	while (nextWriter && nextWriter->IoepIsType(RIoHandle::EPersistentConsole))

		{

		const CIoPersistentConsole* next = (const CIoPersistentConsole*)nextWriter;

		if (chained.Find((TInt)next))

			{

			CleanupStack::PopAndDestroy();

			return EFalse;

			}

		chained.InsertL((TInt)next);

		nextWriter = next->TransientWriter();

		}

	CleanupStack::PopAndDestroy();

	return ETrue;	

	}

void CIoPersistentConsole::AttachTransientWriterL(MIoWriteEndPoint& aWriter, CIoSession* aDetachOnClose)

	{

	if (!CanConnectWriterL(aWriter)) User::Leave(KErrCouldNotConnect);	

	if (iTransientWriteEndPoint)

		{

		User::Leave(KErrInUse);

		}

	iTransientWriteEndPoint = &aWriter;

	CleanupNullPointerPushL((TAny**)&iTransientWriteEndPoint);

	TInt i = 0;

	TRAPD(err, 

		for (i=0; i<iWriterProxies.Count(); ++i)

			{

			iTransientWriteEndPoint->IowepAttachL(*iWriterProxies[i]);

			}

		);

	if (err)

		{

		// deatch the writers the we successfully attached before failure

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

			{

			iWriterProxies[j]->TransientWriterDetach(*iTransientWriteEndPoint);

			}

		User::Leave(err);

		}

	CleanupStack::Pop();

	iWriteEndPointDetachOnClose = aDetachOnClose;

	TRAP_IGNORE(iTransientWriteEndPoint->IowepSetTitleL(iTitleSetter));

	for (TInt i=0; i<iWriterProxies.Count(); ++i)

		{

		iWriterProxies[i]->TransientWriterAttached(*iTransientWriteEndPoint);

		}		

	}

void CIoPersistentConsole::DetachTransientWriter()

	{

	if (!iTransientWriteEndPoint)

		{

		return;

		}

	MIoWriteEndPoint* detaching = iTransientWriteEndPoint;

	iTransientWriteEndPoint = NULL;

	for (TInt i=0; i<iWriterProxies.Count(); ++i)

		{

		iWriterProxies[i]->TransientWriterDetach(*detaching);

		}

	iWriteEndPointDetachOnClose = NULL;

	SendWriteDetachNotifications();

	}

const MIoWriteEndPoint* CIoPersistentConsole::TransientWriter() const

	{

	return iTransientWriteEndPoint;

	}

MIoWriteEndPoint* CIoPersistentConsole::TransientWriter()

	{

	return iTransientWriteEndPoint;

	}

void CIoPersistentConsole::NotifyReadDetachL(const RMsg& aMessage)

	{

	if ((iReaderProxies.Count()==0) || !iTransientReadEndPoint)

		{

		Complete(aMessage, KErrNone);

		}

	else

		{

		iReadDetachNotifications.AppendL(aMessage);

		}

	}

void CIoPersistentConsole::CancelNotifyReadDetach(TRequestStatus* aClientStatus)

	{

	for (TInt i=0; i<iReadDetachNotifications.Count(); ++i)

		{

		if (iReadDetachNotifications[i].ClientStatus() == aClientStatus)

			{

			Complete(iReadDetachNotifications[i], KErrCancel);

			iReadDetachNotifications.Remove(i);

			return;

			}

		}

	}

void CIoPersistentConsole::NotifyWriteDetachL(const RMsg& aMessage)

	{

	if ((iWriterProxies.Count()==0) || !iTransientWriteEndPoint)

		{

		Complete(aMessage, KErrNone);

		}

	else

		{

		iWriteDetachNotifications.AppendL(aMessage);

		}

	}

void CIoPersistentConsole::CancelNotifyWriteDetach(TRequestStatus* aClientStatus)

	{

	for (TInt i=0; i<iWriteDetachNotifications.Count(); ++i)

		{

		if (iWriteDetachNotifications[i].ClientStatus() == aClientStatus)

			{

			Complete(iWriteDetachNotifications[i], KErrCancel);

			iWriteDetachNotifications.Remove(i);

			return;

			}

		}

	}

TName CIoPersistentConsole::TransientReaderName()

	{

	if (iTransientReadEndPoint)

		{

		return iTransientReadEndPoint->IoepName();

		}

	else

		{

		return KNullDesC();

		}

	}

TName CIoPersistentConsole::TransientWriterName()

	{

	if (iTransientWriteEndPoint)

		{

		return iTransientWriteEndPoint->IoepName();

		}

	else

		{

		return KNullDesC();

		}

	}

TThreadId CIoPersistentConsole::Creator()

	{

	return iCreator.Id();

	}

TName CIoPersistentConsole::Name() const

	{

	return iName;

	}

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

	{

	if (aType == RIoHandle::EPersistentConsole)

		{

		return ETrue;

		}

	else

		{

		return CIoConsole::IsType(aType);

		}

	}

void CIoPersistentConsole::SessionClosed(const CIoSession& aSession)

	{

	if (&aSession == iReadEndPointDetachOnClose)

		{

		DetachTransientReader();

		}

	if (&aSession == iWriteEndPointDetachOnClose)

		{

		DetachTransientWriter();

		}

	}

void CIoPersistentConsole::ClosedBy(const CIoSession& aSession)

	{

	SessionClosed(aSession);

	}

void CIoPersistentConsole::SendReadDetachNotifications()

	{

	for (TInt i=0; i<iReadDetachNotifications.Count(); ++i)

		{

		Complete(iReadDetachNotifications[i], KErrNone);

		}

	iReadDetachNotifications.Reset();

	}

void CIoPersistentConsole::SendWriteDetachNotifications()

	{

	for (TInt i=0; i<iWriteDetachNotifications.Count(); ++i)

		{

		Complete(iWriteDetachNotifications[i], KErrNone);

		}

	iWriteDetachNotifications.Reset();

	}

//______________________________________________________________________________

//		MIoReadEndPoint implementation - to handle reads from persistent side

TInt CIoPersistentConsole::HandleReaderAttached(MIoReader& aReader)

	{

	TIoReaderProxy* proxy = new TIoReaderProxy(aReader, *this);

	TInt err = proxy ? KErrNone : KErrNoMemory;

	if (err==KErrNone)

		{

		err = iReaderProxies.Append(proxy);

		}

	if ((err == KErrNone) && iTransientReadEndPoint)

		{

		TRAP(err, iTransientReadEndPoint->IorepAttachL(*proxy, RIoEndPoint::EBackground));

		}

	if (err != KErrNone)

		{

		TInt pos = ReaderProxyIndex(proxy);

		if (pos!=KErrNotFound)

			{

			iReaderProxies.Remove(pos);

			}

		delete proxy;

		}		

	return err;

	}

void CIoPersistentConsole::HandleReaderDetached(MIoReader& aReader)

	{

	TInt pos = ReaderProxyIndex(&aReader);

	if (pos!=KErrNotFound)

		{

		if (iTransientReadEndPoint)

			{

			iTransientReadEndPoint->IorepDetach(*iReaderProxies[pos]);

			}

		delete iReaderProxies[pos];

		iReaderProxies.Remove(pos);

		if (iReaderProxies.Count()==0)

			{

			SendReadDetachNotifications();

			}

		}

	}

void CIoPersistentConsole::HandleForegroundReaderChanged()

	{

	if (iTransientReadEndPoint)

		{

		CIoEndPoint::HandleForegroundReaderChanged();

		}

	else

		{

		ForegroundReaderChanged();

		}

	}

void CIoPersistentConsole::ForegroundReaderChanged()

	{

	MIoReader* fgReader = AttachedReader();

	if (iTransientReadEndPoint && fgReader)

		{

		TInt fgPos = ReaderProxyIndex(fgReader);

		ASSERT(fgPos != KErrNotFound);

		TRAPD(err, iTransientReadEndPoint->IorepSetForegroundReaderL(*iReaderProxies[fgPos]));

		__ASSERT_ALWAYS(err == KErrNone, User::Invariant());

		// this would only fail if this endpoints list of readers differs from the transient

		// endpoints list; the two should always be kept in sync.

		}

	}

TInt CIoPersistentConsole::ReaderProxyIndex(MIoReader* aReader) const

	{

	for (TInt i=0; i<iReaderProxies.Count(); ++i)

		{

		if (&iReaderProxies[i]->ClientReader() == aReader)

			{

			return i;

			}

		}

	return KErrNotFound;

	}

void CIoPersistentConsole::IorepReadL(MIoReader& aReader)

	{

	TInt pos = ReaderProxyIndex(&aReader);

	ASSERT(pos!=KErrNotFound);

	iReaderProxies[pos]->ReadL(iTransientReadEndPoint);

	}

void CIoPersistentConsole::IorepReadKeyL(MIoReader& aReader)

	{

	TInt pos = ReaderProxyIndex(&aReader);

	ASSERT(pos!=KErrNotFound);

	iReaderProxies[pos]->ReadKeyL(iTransientReadEndPoint);

	}

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

	{

	iPersistentConsoleMode = aMode;

	GetReaderProxy(&aReader).SetConsoleModeL(iTransientReadEndPoint, aMode);

	}

//______________________________________________________________________________

//		MIoWriteEndPoint implementation - to handles writes from persistent side

TInt CIoPersistentConsole::HandleWriterAttached(MIoWriter& aWriter)

	{

	// call from CIoEndPoint

	TIoWriterProxy* proxy = new TIoWriterProxy(aWriter, *this);

	TInt err = proxy ? KErrNone : KErrNoMemory;

	if (err==KErrNone)

		{

		err = iWriterProxies.Append(proxy);

		}

	if ((err == KErrNone) && iTransientWriteEndPoint)

		{

		TRAP(err, iTransientWriteEndPoint->IowepAttachL(*proxy));

		}

	if (err != KErrNone)

		{

		TInt pos = WriterProxyIndex(proxy);

		if (pos!=KErrNotFound)

			{

			iWriterProxies.Remove(pos);

			}

		delete proxy;

		}		

	return err;

	}

void CIoPersistentConsole::HandleWriterDetached(MIoWriter& aWriter)

	{

	TInt pos = WriterProxyIndex(&aWriter);

	if (pos!=KErrNotFound)

		{

		if (iTransientWriteEndPoint)

			{

			iWriterProxies[pos]->TransientWriterDetach(*iTransientWriteEndPoint);

			}

		delete iWriterProxies[pos];

		iWriterProxies.Remove(pos);

		if (iWriterProxies.Count()==0)

			{

			SendWriteDetachNotifications();

			}

		}

	}