// Copyright (c) 2002-2009 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:

//

#include <mmf/server/mmfsubthreadbase.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <mmf/server/mmfsubthreadbaseimpl.h>

#endif

EXPORT_C void RMMFSubThreadBase::ReceiveEvents(TMMFEventPckg& aEventPckg, TRequestStatus& aStatus)

	{

	SendReceiveResult(EMMFSubThreadReceiveEvents, aEventPckg, aStatus);

	}

EXPORT_C TInt RMMFSubThreadBase::CancelReceiveEvents()

	{

	return SendReceive(EMMFSubThreadCancelReceiveEvents);

	}

EXPORT_C void RMMFSubThreadBase::Shutdown()

	{

	if (iSubThread.Handle() != KNullHandle)

		{

		// check that the subthread has yet to terminate

		if (iLogonStatus == KRequestPending)

			{	

			//close the subthread and wait for its exit.

			//signal to the subthread to close down.			

			TInt shutdownError = SendReceive(EMMFSubThreadShutdown);

			if (shutdownError != KErrNone)

				{

				iSubThread.LogonCancel(iLogonStatus);

				}

			else

				{

				RTimer timer;

				TInt err = timer.CreateLocal();

				//if we managed to create the timer, wait for both the death and the timeout to minimise the risk of deadlock

				if (!err)

					{

					TRequestStatus timeout;

					timer.After(timeout, iShutdownTimeout);

					User::WaitForRequest(iLogonStatus, timeout);

					if (iLogonStatus == KRequestPending)

						{

						//we have timed out.  Panic the thread in debug mode, kill it in release mode.

						iSubThread.LogonCancel(iLogonStatus);

						User::WaitForRequest(iLogonStatus);

					#ifdef _DEBUG	

						Panic(EMMFSubThreadPanicTimedOut);

					#else

						iSubThread.Kill(KErrDied);

					#endif

						}

					else

						{

						//subthread has exited. Cancel the timer.

						timer.Cancel();

						User::WaitForRequest(timeout);

						}

					}

				else

					{

					//we have no timer so we'll just have to risk the deadlock

					User::WaitForRequest(iLogonStatus);

					}

				timer.Close();

				}

			}

		//close the handle to the subthread

		iSubThread.Close();

		}

	// close our parent

	RHandleBase::Close(); 

	}

void RMMFSubThreadBase::Panic(TMMFSubThreadPanicCode aPanicCode)

	{

	_LIT(KMMFSubThreadPanicCategory, "MMFSubThread");

	iSubThread.Panic(KMMFSubThreadPanicCategory, aPanicCode);

	}

TInt RMMFSubThreadBase::DoCreateSubThread(const TDesC& aName, TThreadFunction aFunction, TBool aUseNewHeap)

	{

	TInt error = KErrNone;

	if (aUseNewHeap)

		{

		error = iSubThread.Create(aName, aFunction,

			KDefaultStackSize, KMinHeapSize, KMMFSubThreadMaxHeapSize, 

			NULL, EOwnerThread);

		}

	else

		{

		error = iSubThread.Create(aName, aFunction,

			KDefaultStackSize, &User::Heap(), 

			NULL, EOwnerThread);

		}

	if (error)

		{

		return error;

		}

	TRequestStatus rendezvous;

	iSubThread.Rendezvous(rendezvous);

	if (rendezvous != KRequestPending)

		{

		iSubThread.Kill(0);

		}

	else

		{

		iLogonStatus = KRequestPending;

		iSubThread.Logon(iLogonStatus);

		if (iLogonStatus != KRequestPending)

			{

			// Failed to log on

			iSubThread.RendezvousCancel(rendezvous);

			User::WaitForRequest(rendezvous);

			iSubThread.Kill(0);

			iSubThread.Close();

			return iLogonStatus.Int();

			}

		else

			{

			iSubThread.Resume();		

			}

		}

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

	if (rendezvous != KErrNone)

		{

		iSubThread.LogonCancel(iLogonStatus);

		User::WaitForRequest(iLogonStatus);

		iSubThread.Close();

		return rendezvous.Int();

		}

	return KErrNone;	

	}

CMMFSubThreadShutdown* CMMFSubThreadShutdown::NewL() 

	{

	CMMFSubThreadShutdown* s = new(ELeave) CMMFSubThreadShutdown();

	CleanupStack::PushL(s);

	s->ConstructL();

	CleanupStack::Pop();

	return s;

	}

CMMFSubThreadShutdown::CMMFSubThreadShutdown() : 

	CTimer(EPriorityLow)

	{

	CActiveScheduler::Add(this);

	}

void CMMFSubThreadShutdown::ConstructL()

	{

	CTimer::ConstructL();

	}

void CMMFSubThreadShutdown::Start()

	{

	After(EMMFSubThreadShutdownDelay);

	}

void CMMFSubThreadShutdown::RunL()

	{

	ShutdownNow();

	}

void CMMFSubThreadShutdown::ShutdownNow()

	{

	CActiveScheduler::Stop();

	}

CMMFSubThreadServer::CMMFSubThreadServer(TInt aPriority) :

	CMmfIpcServer(aPriority)

	{

	}

void CMMFSubThreadServer::ConstructL()

	{

	StartL(RThread().Name());

	iShutdownTimer = CMMFSubThreadShutdown::NewL();

	iShutdownTimer->Start();

	}

CMMFSubThreadServer::~CMMFSubThreadServer()

	{

	delete iShutdownTimer;

	}

void CMMFSubThreadServer::SessionCreated()

	{

	//stop the shutdown timer

	iShutdownTimer->Cancel();

	}

void CMMFSubThreadServer::ShutdownNow()

	{

	iShutdownTimer->ShutdownNow();

	}

TInt CMMFSubThreadServer::RunError(TInt aError)

	{

	//signal the client

	Message().Complete(aError);

	ReStart();

	return KErrNone;

	}

CMMFSubThreadEventReceiver* CMMFSubThreadEventReceiver::NewL(const RMmfIpcMessage& aMessage)

	{

	return new(ELeave) CMMFSubThreadEventReceiver(aMessage);

	}

CMMFSubThreadEventReceiver::~CMMFSubThreadEventReceiver()

	{

	if (iNeedToCompleteMessage)

		iMessage.Complete(KErrDied);

	}

void CMMFSubThreadEventReceiver::SendEvent(const TMMFEvent& aEvent)

	{

	TMMFEventPckg eventpckg(aEvent);

	TRAPD(err, MmfMessageUtil::WriteL(iMessage, 0, eventpckg));

	iMessage.Complete(err);

	iNeedToCompleteMessage = EFalse;

	}

CMMFSubThreadEventReceiver::CMMFSubThreadEventReceiver(const RMmfIpcMessage& aMessage) : 

	iMessage(aMessage)

	{

	iNeedToCompleteMessage = ETrue;

	}

void CMMFSubThreadSession::CreateL(const CMmfIpcServer& aServer)

	{

	CMmfIpcSession::CreateL(aServer);

	iServer = STATIC_CAST(CMMFSubThreadServer*, (CONST_CAST(CMmfIpcServer*, &aServer)));

	iServer->SessionCreated();

	}

CMMFSubThreadSession::~CMMFSubThreadSession()

	{

	delete iEventReceiver;

	iEvents.Close();

	}

TBool CMMFSubThreadSession::ReceiveEventsL(const RMmfIpcMessage& aMessage)

	{

	if (iEventReceiver)

		User::Leave(KErrAlreadyExists);

	iEventReceiver = CMMFSubThreadEventReceiver::NewL(aMessage);

	//send the next cached event (if any) to the client

	if (iEvents.Count() > 0)

		{

		TMMFEvent& event = iEvents[0];

		iEventReceiver->SendEvent(event);

		delete iEventReceiver;

		iEventReceiver=NULL;

		iEvents.Remove(0);

		}

	return EFalse;

	}

TBool CMMFSubThreadSession::CancelReceiveEvents()

	{

	delete iEventReceiver;

	iEventReceiver = NULL;

	return ETrue;

	}

TBool CMMFSubThreadSession::ShutDown()

	{

	iServer->ShutdownNow();

	return ETrue;

	}

TInt CMMFSubThreadSession::SendEventToClient(const TMMFEvent& aEvent)

	{

	TInt error = KErrNone;

	if (iEventReceiver)

		{

		//send event to client now

		iEventReceiver->SendEvent(aEvent);

		delete iEventReceiver;

		iEventReceiver=NULL;

		error = KErrNone;

		}

	else

		{

		//queue the request for later

		TMMFEvent event(aEvent);

		//if we've exceeded the max number of cached messages, delete the first and append this one to the end

		if (iEvents.Count() >= KMMFSubThreadMaxCachedMessages)

			iEvents.Remove(0);

		error = iEvents.Append(event);

		}

	return error;

	}