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

// Name        : timerhandler.cpp

// Part of     : librt-timer specific cpp file

// This is a project specific source file for building the 

// timer related functions as part of librt library.

// 

//

#include "sysif.h"

#include "timerhandler.h"

#include "timerclient.h"

#include "timerserver.h"

#include "timermessage.h"

#include "timer.h"

#include <pthread.h>

#ifdef __WINSCW__ 

#include <pls.h> // For emulator WSD API 

const TUid KLibrtUid3 = {0x2001E553}; 

#elif defined __X86GCC__

CTimerReqHandler gTimerHandler;

#endif

CTimerReqHandler* getTimerHandler()

	{

#ifdef __WINSCW__	

	// Access the PLS of this process

	CTimerReqHandler* lTimerHandlerPtr = Pls<CTimerReqHandler>(KLibrtUid3); 

	return lTimerHandlerPtr;  

#elif defined __X86GCC__

	return &gTimerHandler;

#else

	static CTimerReqHandler sgTimerHandler;

	return &sgTimerHandler;

#endif

	}

 CTimerReqHandler::CTimerReqHandler() : iTimers(CTimerReqHandler::KTimersGran)

	{

	iTimersLock.CreateLocal();

	iServConnectLock.CreateLocal();

	iTimerSemaphore.CreateLocal(0);

	}

 CTimerReqHandler::~CTimerReqHandler()

	{

	iTimersLock.Close();

	iTimers.ResetAndDestroy();

	iTimerSemaphore.Close();

	iServ.Close();

	iServConnectLock.Close();

	}

//method to create a timer

TInt CTimerReqHandler::CreateTimer(TInt& aTimerId, struct sigevent *aSig)

	{

	TInt lRet = KErrNone;

	if(iTimers.Count() >= MAXTIMERLIMIT)

		{

		lRet = KErrWouldBlock;

		}

	if(lRet == KErrNone)

		{

		if(aSig != NULL)

			{

			switch(aSig->sigev_notify)	

				{

				case SIGEV_SIGNAL:

#if (!defined SYMBIAN_OE_POSIX_SIGNALS || !defined SYMBIAN_OE_LIBRT)

					{

					aTimerId = -1;

					lRet = KErrNotSupported;

					break;	

					}

#else			

				if(aSig->sigev_signo < 1 || aSig->sigev_signo > SIGRTMAX)

					{

					aTimerId = -1;

					lRet = KErrArgument;						

					}

#endif	

				case SIGEV_NONE:					

				case SIGEV_THREAD:

					break;

				default:

					aTimerId = -1;	

					lRet = KErrArgument;

					break;

				}

			}

		if(lRet == KErrNone)	

			{

			RHeap* oldHeap = User::SwitchHeap(Backend()->Heap());

			CRtTimer *lTimer = CRtTimer::New(aSig);

			if(NULL == lTimer)

				{

				aTimerId = -1;	

				lRet = KErrNoMemory;

				User::SwitchHeap(oldHeap);

				}

			else

				{

				aTimerId = lTimer->iTimerId;				

				iTimersLock.Wait();	

				TRAP(lRet, iTimers.AppendL(lTimer));				

				User::SwitchHeap(oldHeap);

				iTimersLock.Signal();			

				}	

			}

		}

	return lRet;	

	}

//method to delete a timer

TInt CTimerReqHandler::RemoveTimer(const TInt& aTimerId)

	{

	if(FindTimer(aTimerId)== NULL)

		{

		return KErrArgument;

		}

	TInt lRet = Connect();

	if(lRet == KErrNone)

		{

		session.OnDemandConnect(iServer);

		lRet = session.DeleteTimer(aTimerId);

		}	

	return lRet;		

	}

//method to set a new timeout value for a timer

TInt CTimerReqHandler::SetTime(const TInt& aTimerId, TInt aFlag, const struct itimerspec *aIpTime,

			 struct itimerspec *aOpTime) 

	{

	TInt lRet = Connect();

	if(lRet == KErrNone)

		{

		CRtTimer* lTimer = FindTimer(aTimerId);	

		if(lTimer != NULL)

			lRet = lTimer->SetTime(aFlag, aIpTime, aOpTime);	

		else

			lRet = KErrArgument;	

		}

	return lRet;	

	}

//method to makesure that the timer server is started only once on demand.

TInt CTimerReqHandler::Connect()

	{

	TInt lRet = KErrNone;

	iServConnectLock.Wait();

	if(!iIsServStarted)

		{

		lRet = StartTimerServer();

		if(lRet == KErrNone)

			iIsServStarted = ETrue;

		}

	iServConnectLock.Signal();

	return lRet;		

	}

//start up function for the timer server.

static TInt sTimerServer(TAny*)

	{

	RHeap *oldHeap = User::SwitchHeap(Backend()->Heap());

	CTrapCleanup* cleanup = CTrapCleanup::New();

	TRAPD(ret, CTimerServer::NewTimerServerL());

	delete cleanup;

	User::SwitchHeap(oldHeap);

	return ret;

	}

//method to start the timer server

TInt CTimerReqHandler::StartTimerServer()

	{

	TRequestStatus status;

	TInt lRet = iServ.Create(KNullDesC, sTimerServer, 

			KDefaultStackSize, NULL, (TAny*)NULL);

	if(lRet == KErrNone)							

		{

		iServ.SetPriority(EPriorityAbsoluteHigh);// match the signal server priority.

		iServ.Rendezvous(status);

		iServ.Resume(); //get this ready

		User::WaitForRequest(status);

		}

	return lRet;

	}

//method to get the "time to expiration" of a timer

TInt CTimerReqHandler::Time(const TInt& aTimerId, struct itimerspec *aTime)

	{

 	CRtTimer* lTimer = FindTimer(aTimerId);

	if(lTimer == NULL)

		return KErrArgument;	

	return lTimer->Time(aTime);

	}

//method to get the overruns for a timer

TInt CTimerReqHandler::OverrunCount(const TInt& aTimerId, TInt& aOverrunCount)

	{

	CRtTimer* lTimer = FindTimer(aTimerId);

	if(lTimer == NULL)

		return KErrArgument;		

	return lTimer->OverrunCount(aOverrunCount);

	}

//find the timer with the given timer id

CRtTimer* CTimerReqHandler::FindTimer(const TInt& aTimerId)

	{

	CRtTimer* lRtTimerP = NULL;

	iTimersLock.Wait();	

	TInt lTimerCount = iTimers.Count();	

	for(TInt lIdx =0; lIdx < lTimerCount; lIdx++)

		{

		if(iTimers[lIdx]->iTimerId == aTimerId)

			{

			lRtTimerP = (iTimers[lIdx]);

			break;	

			}

		}

	iTimersLock.Signal();

	return lRtTimerP;	

	}