// 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;	

 	}