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