/*
* Copyright (c) 2010 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 "CWorker.h"

#include "robustnesstest.pan"

#include <e32math.h>

TInt LogRand( TInt aDeviation ) 
	{
	TInt rv = 0; 
	while ( Math::Random() % aDeviation ) rv++;
	return rv; 
	}

void SleepRandom( TInt aAverageMs ) 
	{
	TInt sleepMs = LogRand( 10 ) * aAverageMs / 10; 
	User::After( sleepMs * 1000 );
	}

CWorker::CWorker() 
	: iWorkerId( iNextFreeWorkerId++ ),
	  iError( KErrNone ),
	  iExitTime(),
      iReported(),
      iActive( EFalse ),
	  iThread(), 
	  iSemaphore(),
	  iLock()
	  	{
		}

void CWorker::ConstructL() 
	{
	User::LeaveIfError( iSemaphore.CreateLocal( 0 ) ); 
	User::LeaveIfError( iLock.CreateLocal( 1 ) ); 
	}

CWorker::~CWorker() 
	{
	if ( iActive ) 
		{
		Cancel(); 
		while ( TryJoin(1000) != KErrNone ){}

		}
	iSemaphore.Close(); 
	iLock.Close(); 
	}

TInt CWorker::WorkerId() 
	{
	return iWorkerId; 
	}

TInt CWorker::Error() 
	{
	return iError; 
	}

const TTime& CWorker::ExitTime()
	{
	return iExitTime; 
	}

TBool CWorker::IsReported() 
	{
	return iReported; 
	}

void CWorker::SetReported() 
	{
	iReported = ETrue; 
	}

TBool CWorker::IsActive() 
	{
	return iActive; 
	}

void CWorker::StartL() 
	{
	iError = KErrNone;
	iReported = EFalse; 
	
	TThreadFunction function = CWorker::ThreadFunction; 
	
	User::LeaveIfError( iThread.Create( Name(), function, 2048, 0, this ) ); 
	 
	iActive = ETrue;
	iThread.Resume(); 
	// Go thread go
	
}

void CWorker::Cancel() 
	{
	DoCancel(); 
	}

TInt CWorker::TryJoin( TInt aMicroSeconds ) 
	{
	TInt err = iSemaphore.Wait( aMicroSeconds );
	if ( err == KErrNone ) 
		{
		iActive = EFalse;
		iThread.Close();
		}
	return err;
	}

void CWorker::Terminate() 
	{
	iActive = EFalse;
	iThread.Panic( KRobustnessTestPanicCategory, KRobustnessTestTerminate ); 
	iThread.Close();
	}

void CWorker::Wait( TReal aSeconds ) 
	{
	RTimer timer; 
	TRequestStatus timerStatus; 
	timer.CreateLocal();        
	CleanupClosePushL( timer ); 
	
	timer.After( timerStatus, aSeconds * 1000 * 1000 ); 
	User::WaitForRequest(timerStatus); 
	
	CleanupStack::PopAndDestroy(); // timer 
	}

void CWorker::Lock() {
	iLock.Wait(); 
}

TInt CWorker::TryLock( TInt aMicroSeconds ) {
	return iLock.Wait( aMicroSeconds ); 
}

void CWorker::Unlock() {
	iLock.Signal(); 
}

void CWorker::RunL() 
	{
	CActiveScheduler* scheduler = new (ELeave) CActiveScheduler();
	CleanupStack::PushL(scheduler);
	CActiveScheduler::Install(scheduler);
	
	Lock(); 
	TRAP(iError, DoRunL()); 
	iExitTime.HomeTime(); 
	Unlock(); 
	
	iSemaphore.Signal(); 
	
	CleanupStack::PopAndDestroy(scheduler);
	}

TInt CWorker::ThreadFunction(void *aThis) 
	{
	CTrapCleanup* cleanup = CTrapCleanup::New();

	TRAP_IGNORE
		( 
		(reinterpret_cast<CWorker*>(aThis))->RunL();
		); 

	delete cleanup;
	return KErrNone;
	}

TInt CWorker::iNextFreeWorkerId = 0;