// Copyright (c) 2007-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:
// Contains the CThreadExec class definition.
// 
//

/**
 @file 
 @internalTechnology
*/
 
#include "cthreadexec.h"
#include "cctsytestlogging.h"

CThreadExec* CThreadExec::NewL()
	{	
	TEST_FRAMEWORK_LOG1(_L("CThreadExec::NewL"));
	CThreadExec* self = new(ELeave) CThreadExec();
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self;
	}
	
CThreadExec::CThreadExec()
	{
	}
	
void CThreadExec::ConstructL()
	{
	TEST_FRAMEWORK_LOG1(_L("CThreadExec::ConstructL"));
	iActiveFnExec = CActiveFnExec::NewL(*this);
	CActiveScheduler::Add(iActiveFnExec);
	
	iExecSemaphore.CreateLocal(0);
	iActiveFnExec->Start();
	}
	
CThreadExec::~CThreadExec()
	{
	TEST_FRAMEWORK_LOG1(_L("CThreadExec::~CThreadExec"));
	iActiveFnExec->Cancel();
	delete iActiveFnExec;
	}

TInt CThreadExec::Exec(MFunctor* aFunction)
	{
	TEST_FRAMEWORK_LOG1(_L("CThreadExec::Exec"));
	iFunction = aFunction;
    iNeedSignal = ETrue;
	iActiveFnExec->Exec();
	// wait for the function to terminate
	iExecSemaphore.Wait();
	return iLatestError;
	}

void CThreadExec::DoExec()
	{
	TEST_FRAMEWORK_LOG1(_L("CThreadExec::DoExec"));
	// run the exec function
	iLatestError = KErrNone;
	TRAP(iLatestError, iFunction->ExecL());
	// signal called it's done
	if(iNeedSignal)
		{
		iExecSemaphore.Signal();
		}
	}

void CThreadExec::AsyncExec(MFunctor* aFunction)
/**
 *   Execute a function asynchronously. 
 *   This will execute the function in another thread, without waiting for completion (while the Exec will do the same, but the it will wait for the function completion).
 *   @param aFunction the function to execute
 */
	{
	iFunction = aFunction;
	iNeedSignal = EFalse;
	iActiveFnExec->Exec();
	}

CThreadExec::CActiveFnExec* CThreadExec::CActiveFnExec::NewL(CThreadExec& aOwner)
	{
	TEST_FRAMEWORK_LOG1(_L("CThreadExec::CActiveFnExec::NewL"));
	CActiveFnExec* self = new(ELeave) CActiveFnExec(aOwner);
	return self;
	}

CThreadExec::CActiveFnExec::CActiveFnExec(CThreadExec& aOwner)
	: CActive(CActive::EPriorityHigh),iOwner(aOwner)
	{
	TEST_FRAMEWORK_LOG1(_L("CThreadExec::CActiveFnExec::CActiveFnExec"));
	// open a reference to the current thread
	iThread.Open(RThread().Id());
	}

void CThreadExec::CActiveFnExec::Start()
	{
	TEST_FRAMEWORK_LOG1(_L("CThreadExec::CActiveFnExec::Start"));
	iStatus = KRequestPending;
	SetActive();
	}
	
void CThreadExec::CActiveFnExec::Exec()
	{
	TEST_FRAMEWORK_LOG1(_L("CThreadExec::CActiveFnExec::Exec"));
	// signal the main thread 
	TRequestStatus* reqStatus = &iStatus;
	iThread.RequestComplete(reqStatus, KErrNone);
	}

void CThreadExec::CActiveFnExec::RunL()
	{
	TEST_FRAMEWORK_LOG1(_L("CThreadExec::CActiveFnExec::RunL"));
	iOwner.DoExec();
	iStatus = KRequestPending;
	SetActive();
	}

void CThreadExec::CActiveFnExec::DoCancel()
	{
	TEST_FRAMEWORK_LOG1(_L("CThreadExec::CActiveFnExec::DoCancel"));
	TRequestStatus* reqStatus = &iStatus;
	User::RequestComplete(reqStatus, KErrCancel);
	}