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

//

// system includes

#include <schtask.h>

// User includes

#include "SCHEXEC.H"

#include "SchLogger.h"

#include "SCHLOG.h"

#include "taskfile.h"

//Delay ensuring this thread is be preempted allowing client cleanup

//in case task file cannot be deleted

const TInt KClientCleanupDelay = 10000;

CTaskExecutor::CTaskExecutor(CSchLogManager& aSchLogManager)

:	CActive(EPriorityStandard), 

	iSchLogManager(aSchLogManager)

	{

	CActiveScheduler::Add(this);

	}

CTaskExecutor::~CTaskExecutor()

	{

	LOGSTRING("CTaskExecutor::~CTaskExecutor - start");

	iProcess.Close();

	//

	delete iClientFileName;

	delete iTaskFileName;

	delete iLogErrorMessage;

	LOGSTRING("CTaskExecutor::~CTaskExecutor - end");

	}

void CTaskExecutor::ConstructL(const TDesC& aTaskFileName, 

								const TDesC& aClientFileName, 

								const TDesC& aErrorMessage)

	{

	LOGSTRING("CTaskExecutor::ConstructL - start");

	// Store filename

	iTaskFileName = aTaskFileName.AllocL();

	iClientFileName = aClientFileName.AllocL();

	// In case there is an error...

	iLogErrorMessage = aErrorMessage.AllocL();

	LOGSTRING("CTaskExecutor::ConstructL - end");

	}

CTaskExecutor* CTaskExecutor::NewLC(const TDesC& aErrorMessage, 

									const TDesC& aTaskFileName, 

									const TDesC& aClientFileName,

									CSchLogManager& aSchLogManager)

	{

	LOGSTRING("CTaskExecutor::NewLC");

	CTaskExecutor* self = new(ELeave) CTaskExecutor(aSchLogManager);

	CleanupStack::PushL(self);

	self->ConstructL(aTaskFileName,	aClientFileName, aErrorMessage);

    return self;

	}

void CTaskExecutor::RunL()

	{

	LOGSTRING3("CTaskExecutor::RunL - task finished running [client: %S, task: %S]", iClientFileName, iTaskFileName);

	//

	// RunL is called when the process/thread terminates

	// so that any error conditions can be handled.

	TInt exitReason = iProcess.ExitReason();

	LOGSTRING2("CTaskExecutor::RunL - process exit reason was: %d", exitReason);

	// Close the process/thread

	iProcess.Close();

	// Check for error code

	if	(exitReason != KErrNone)

		{

		// Submit a log entry to record the error. 

		LOGSTRING2("CTaskExecutor::RunL - recording unclean process exit (%d) in the log engine", exitReason);

		if(iLogErrorMessage)

			iSchLogManager.LogError(*iLogErrorMessage,exitReason);

		else

			iSchLogManager.LogError(exitReason);			

		}

	// Clean up the file.  Only delete it here once task process has finished.

	// If task process never started then file is deleted in CClientProxy code.

	User::LeaveIfError(iFsSession.Connect());

	CleanupClosePushL(iFsSession);

	TInt fileDeleteErr = iFsSession.Delete(*iTaskFileName);

	// If unable to delete file wait and try again

	if (fileDeleteErr != KErrNone)

		{

		//Allow thread to be preempted to allow for cleanup of iProcess

		User::After(KClientCleanupDelay);

		fileDeleteErr = iFsSession.Delete(*iTaskFileName);

		// If still unable to delete file record the fact

		if (fileDeleteErr != KErrNone)

			{				

			if(iLogErrorMessage)

				{		

				iSchLogManager.LogError(*iLogErrorMessage, fileDeleteErr);

				}

			else

				{

				iSchLogManager.LogError(fileDeleteErr);

				}				

			}

		}

	//Calls iFsSession::Close() so no need to call explicitly

	CleanupStack::PopAndDestroy();

	// Delete outselves since we've finished

	LOGSTRING("CTaskExecutor::RunL - deleting ourself");

	delete this;

	}	

void CTaskExecutor::DoCancel()

	{

	LOGSTRING("CTaskExecutor::DoCancel - start");

	iProcess.LogonCancel(iStatus);

	// Delete file and ourselves since we can't do anything else.

	// We are in a bad state if we reach here but at least make the most of it.

	LOGSTRING("CTaskExecutor::DoCancel - deleting ourself");

	//Connect to file session

	TInt err = iFsSession.Connect();

	if(err == KErrNone)

		{

		err = iFsSession.Delete(*iTaskFileName);

		}

	// If unable to delete file record the fact

	if (err != KErrNone)

		{

		if(iLogErrorMessage)

			{

			iSchLogManager.LogError(*iLogErrorMessage, err);

			}

		else

			{

			iSchLogManager.LogError(err);

			}

		}

	//Close the file session

	iFsSession.Close();

	delete this;

	LOGSTRING("CTaskExecutor::DoCancel - end");

	}	

void CTaskExecutor::ExecuteL()

	{

	// If this leaves, CClientProxy should handle error....

	// CTaskScheduler::ExecuteClients() traps the leave and then calls

	// CClientProxy::FailToExecute() to handle the error.

#ifdef __SCHLOGGING__

	{

	TTime time; time.HomeTime();

	TDateTime due = time.DateTime();

	LOGSTRING8("CTaskExecutor::ExecuteL - Executing tasks at: [%02d/%02d/%d] @ %02d:%02d:%02d.%05d", due.Day(), (TInt) due.Month() + 1, due.Year(), due.Hour(), due.Minute(), due.Second(), due.MicroSecond());

	}

#endif

	// Create a new process and pass the name of the task file as the command line argument

	// (data for the target exe).

	LOGSTRING("CTaskExecutor::ExecuteL - creating process");

	TInt err = iProcess.Create(*iClientFileName, KNullDesC);

	// Will check the error, report the problem and leave (if err<KErrNone)

	// otherwise does nothing.

	LOGSTRING("CTaskExecutor::ExecuteL - checking process creation error code");

	CheckErrorAndLeaveL(err);

	// connect to new file session to avoid possible security

	// consequences if lauched process tries to use passed file in

	// subversive way.

	User::LeaveIfError(iFsSession.Connect());

	CleanupClosePushL(iFsSession);

	User::LeaveIfError(iFsSession.ShareProtected());

	User::LeaveIfError(iTaskFile.Open(iFsSession, *iTaskFileName, EFileRead));

	CleanupClosePushL(iTaskFile);

	// transfer file handle to launched process

	err = iTaskFile.TransferToProcess(iProcess, KTaskFsHandleIndex, KTaskFileHandleIndex);

	//Close task file and session handles

	//Calls iFsSession::Close() and iTaskFile::Close() so no need to call explicitly

	CleanupStack::PopAndDestroy(2);

	CheckErrorAndLeaveL(err);

	// Asynchronous logon: completes when process terminates with process exit code

	iProcess.Logon(iStatus);

	iProcess.Resume();

	SetActive();

	LOGSTRING("CTaskExecutor::ExecuteL - end");

	}

void CTaskExecutor::CheckErrorAndLeaveL(TInt aError)

	{

	if	(aError < KErrNone)

		{

		if(iLogErrorMessage)

			iSchLogManager.LogError(*iLogErrorMessage,aError);

		else

			iSchLogManager.LogError(aError);			

		User::Leave(aError);

		}

	}