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

//

/**

 @file

 @internalComponent

*/

#include "cs_glob.h"

#include <e32std.h>

#include "C32LOG.H"

#include "cs_roles.h"

#include "cs_thread.h"

CC32Data* CC32Data::NewL()

		{

		return new(ELeave) CC32Data();

		}

CC32Data::CC32Data()

	{

	}

CC32WorkerThread* CC32Data::SelfWorker() const

	{ 

	return iWorkerThread;

	}

void C32GlobalUtil::InitC32GlobalsL(CC32WorkerThread* aWorker)

	{

	CTLSRedirector* tls = CRedirectorInTls();

	if(tls)

		{

		Fault(EInitTwice);

		}

	// Allocate global storage to be held in tls.

	// only transfer ownership to tls at end since if we fail, the thread is never started

	CC32Data *globals=CC32Data::NewL();

	CleanupStack::PushL(globals);

	// Pre allocate the shutdown timer so that we can always shut down.

	globals->iShutdownWatchDog=CC32ShutdownWatchDog::NewL();

#ifdef _DEBUG

	globals->iShutdownWatchDog->SetWorkerId(aWorker->WorkerId());

#endif

	CleanupStack::PushL(globals->iShutdownWatchDog);

	globals->iWorkerThread = aWorker;

	tls = CTLSRedirector::NewL();

	CleanupStack::PushL(tls);

	CDeltaTimer* timer = CDeltaTimer::NewL(CActive::EPriorityHigh, KCommTimerGranularity);

	tls->SetDeltaTimer(timer); // ownership	transferred

	tls->SetC32GlobalData(globals); //ownership transferred

	Dll::SetTls(tls);  // owned now indirectly by the worker thread which must now remove it when shutting down

	CleanupStack::Pop(3); //watchdog, globals, tls

	C32LOG1(KC32Bootup, _L("C32GlobalUtil::InitL() Done!"));

	}

void C32GlobalUtil::ShutDown()

/**

free data structures

*/

	{

	// Mark ourself as on the way out

	CC32Data* globals = CC32DataInTls();

	CTLSRedirector* tls = CRedirectorInTls();

	// The CC32Data destructor does not own so does not delete the data it points

	// This is since don't want to delete the Watchdog - it is left to delete itself.

	// So we delete everything else in CC32Data explicitly.

	C32LOG2(KC32Shutdown, _L("--------------- C32Server W%d starting shutdown ---------------"), globals->iWorkerThread->WorkerId());

	delete globals->iWorkerThread;

	delete tls;

	Dll::SetTls(NULL); // so that logger sees it is gone.

	}

void C32GlobalUtil::NewSession()

/**

Increment the session counter - if we were about to shutdown, stop.

*/

	{

	CC32Data* globals = CC32DataInTls();

	globals->iNumSessions++;

	C32LOG2(KC32Detail, _L8("C32GlobalUtil::NewSession() iNumSessions= %d "), globals->iNumSessions );

	}

void C32GlobalUtil::SessionClosing()

/**

A session is closing, if it's the last one take our stumps home.

*/

	{

	CC32Data* globals = CC32DataInTls();

	globals->iNumSessions--;

	C32LOG2(KC32Detail, _L8("C32GlobalUtil::SessionClosing() iNumSessions= %d "), globals->iNumSessions );

	CC32WorkerThread* selfWorker = globals->SelfWorker();

	if (selfWorker->ShuttingDown())

		{

		C32LOG2(KC32Shutdown, _L8("Shutdown requested: %d sessions"), globals->iNumSessions );

		if (globals->iNumSessions <= 0)

			{

			if(selfWorker->IsMainThread())

				{

				selfWorker->DealerByRef().SessionShutdownComplete();

				}

			else

				{

				selfWorker->MaybeTriggerThreadShutdownCallback();

				}

			}

		}

	}

CTLSRedirector* CTLSRedirector::NewL()

		{

		return new(ELeave) CTLSRedirector();

		}

CTLSRedirector::~CTLSRedirector()

	{

	delete iTimer;

	delete iC32Data;

	}

CC32ShutdownWatchDog::CC32ShutdownWatchDog()

	:CTimer(EPriorityLow)

/**

Constructor

*/

	{

	}

void CC32ShutdownWatchDog::Shutdown()

/**

Que ourselves to shut the C32 server down after a suitable delay.

*/

	{

	C32LOG1(KC32Shutdown, _L("CC32ShutdownWatchDog::Shutdown()"));

	if (!IsAdded())

		{

		CActiveScheduler::Add(this);

		}

	if(!IsActive())

		{

		After(KCommServerShutdownLatencyMicroSeconds);

		}

	}

void CC32ShutdownWatchDog::RunL()

	{

	C32LOG1(KC32Shutdown, _L("CC32ShutdownWatchDog::RunL()"));	

	ASSERT(CC32DataInTls()->iNumSessions == 0);

	// End of the line

	C32GlobalUtil::ShutDown();

	CActiveScheduler::Stop();

	// tls is now deleted, so we mimmick our workerId description on the log line:

    C32LOG2(KC32Shutdown, _L("W%d: CC32ShutdownWatchDog::RunL() - about to delete self, which is last step of shutdown"),iWorkerId);

	delete this;

	}

CC32ShutdownWatchDog* CC32ShutdownWatchDog::NewL()

	{

	CC32ShutdownWatchDog* t=new (ELeave) CC32ShutdownWatchDog();

	CleanupStack::PushL(t);

	t->ConstructL();

	CleanupStack::Pop(t);

	return t;

	}

#ifdef _DEBUG

void CC32ShutdownWatchDog::SetWorkerId(TWorkerId aWorkerId)

	{

	iWorkerId = aWorkerId;

	}

#endif

// EOF - CS_GLOB.CPP