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


/**
@test
@internalComponent

This contains CT_FileManData
*/

//	User includes
#include "T_FileManData.h"
#include "T_SfSrvServer.h"

const TInt KMaxFileNameLength		=255;

/*@{*/
///	Parameters
_LIT(KPath,										"path");
_LIT(KFileName,									"filename");
_LIT(KFileFrom,									"filefrom");
_LIT(KFileTo,									"fileto");
_LIT(KOldName,									"oldname");
_LIT(KNewName,									"newname");
_LIT(KRFsObject,								"rfsObject");
_LIT(KRFileObject,								"rfileObject");
_LIT(KUseObserver,								"use_observer");
_LIT(KAsync,									"async");
_LIT(KTime,										"time");
_LIT(KSetMask,									"setmask");
_LIT(KClearMask,								"clearmask");
_LIT(KOperation,								"operation");
_LIT(KCurrentAction,							"current_action");
_LIT(KBytes,									"bytes");
_LIT(KError,									"error");
_LIT(KTarget,									"target");
_LIT(KSource,									"source");
_LIT(KNotifyType,								"notify_type");
_LIT(KReadHistory,								"read_history");
_LIT(KName,										"name");
_LIT(KNullDesCStr,								"KNullDesC");
_LIT(KTotalBytes,								"total_bytes");
_LIT(KFlag,										"flag");
_LIT(KClearHistory,								"clear_history");
_LIT(KSetTcontrol,								"set_tcontrol");
//For searching file names.
_LIT(KPattern, 									"*%S*");

/// Commands
_LIT(KCmdNewL,									"NewL");
_LIT(KCmdAttribs,								"Attribs");
_LIT(KCmdCopy,									"Copy");
_LIT(KCmdMove,									"Move");
_LIT(KCmdDelete,								"Delete");
_LIT(KCmdRename,								"Rename");
_LIT(KCmdRmDir,									"RmDir");
_LIT(KCmdSetObserver,							"SetObserver");
_LIT(KCmdCurrentAction,							"CurrentAction");
_LIT(KCmdGetCurrentTarget,						"GetCurrentTarget");
_LIT(KCmdGetCurrentSource,						"GetCurrentSource");
_LIT(KCmdBytesTransferredByCopyStep,			"BytesTransferredByCopyStep");
_LIT(KCmdCurrentEntry,							"CurrentEntry");
_LIT(KCmdAbbreviatedPath,						"AbbreviatedPath");
_LIT(KCmdFullPath,								"FullPath");
_LIT(KCmdGetLastError,							"GetLastError");
_LIT(KCmdGetMoreInfoAboutError,					"GetMoreInfoAboutError");
_LIT(KCmdDestructor,							"~");

// TActions
_LIT(KENone,									"ENone");
_LIT(KEAttribs,									"EAttribs");
_LIT(KECopy,									"ECopy");
_LIT(KEDelete,									"EDelete");
_LIT(KEMove,									"EMove");
_LIT(KERename,									"ERename");
_LIT(KERmDir,									"ERmDir");
_LIT(KERenameInvalidEntry,						"ERenameInvalidEntry");
_LIT(KECopyFromHandle,							"ECopyFromHandle");


// TSwitch
_LIT(KEOverWrite,								"EOverWrite");
_LIT(KERecurse,									"ERecurse");

// TControl
_LIT(KEContinue,								"EContinue");
_LIT(KEAbort,									"EAbort");
_LIT(KECancel,									"ECancel");
_LIT(KERetry,									"ERetry");

// TFileManError
_LIT(KENoExtraInformation,						"ENoExtraInformation");
_LIT(KEInitializationFailed,					"EInitializationFailed");
_LIT(KEScanNextDirectoryFailed,					"EScanNextDirectoryFailed");
_LIT(KESrcOpenFailed,							"ESrcOpenFailed");
_LIT(KETrgOpenFailed,							"ETrgOpenFailed");
_LIT(KENoFilesProcessed,						"ENoFilesProcessed");

//Notifys
_LIT(KNotifyStarted,							"started");
_LIT(KNotifyOperation,							"operation");
_LIT(KNotifyEnded,								"ended");



CT_FileManData* CT_FileManData::NewL()
/**
* Two phase constructor
*/
	{
	CT_FileManData* ret = new (ELeave) CT_FileManData();
	CleanupStack::PushL(ret);
	ret->ConstructL();
	CleanupStack::Pop(ret);
	return ret;
	}


CT_FileManData::CT_FileManData()
:	iFileMan(NULL)
,	iAsyncErrorIndex(0)
,	iAsyncCall(EFalse)
,	iFileManObserver(NULL)
,	iUseTControl(EFalse)

/**
* Protected constructor. First phase construction
*/
	{
	}


void CT_FileManData::ConstructL()
/**
* Protected constructor. Second phase construction
*/
	{
	}


CT_FileManData::~CT_FileManData()
/**
* Destructor.
*/
	{
	DoCleanup();
	
	iAttribs.ResetAndDestroy();
	iCopy.ResetAndDestroy();
	iDelete.ResetAndDestroy();
	iMove.ResetAndDestroy();
	iRename.ResetAndDestroy();
	iRmDir.ResetAndDestroy();
	
	ClearHistory();
	}
	
TAny* CT_FileManData::GetObject()
	{
	return iFileMan;
	}
	

TBool CT_FileManData::DoCommandL(const TTEFFunction& aCommand, const TTEFSectionName& aSection, const TInt aAsyncErrorIndex)
/**
* Process a command read from the ini file
*
* @param aCommand	the command to process
* @param aSection	the section in the ini file requiring the command to be processed
*
* @return ETrue if the command is processed
*/
	{
	TBool retVal = ETrue;

	if (aCommand == KCmdNewL)
		{
		DoCmdNewL(aSection);
		}
	else if (aCommand == KCmdDestructor)
		{
		DoCleanup();
		}
	else if (aCommand == KCmdAttribs)
		{
		DoCmdAttribsL(aSection, aAsyncErrorIndex);
		}
	else if (aCommand == KCmdCopy)
		{ 
		DoCmdCopyL(aSection, aAsyncErrorIndex);
		}
	else if (aCommand == KCmdMove)
		{
		DoCmdMoveL(aSection, aAsyncErrorIndex);
		}
	else if (aCommand == KCmdDelete)
		{
		DoCmdDeleteL(aSection, aAsyncErrorIndex);
		}
	else if (aCommand == KCmdRename)
		{
		DoCmdRenameL(aSection, aAsyncErrorIndex);
		}	
	else if (aCommand == KCmdRmDir)
		{
		DoCmdRmDirL(aSection, aAsyncErrorIndex);
		}
	else if (aCommand == KCmdSetObserver)
		{
		DoCmdSetObserver();
		}
	else if (aCommand == KCmdCurrentAction)
		{
		DoCmdCurrentAction(aSection);
		}
	else if (aCommand == KCmdGetCurrentTarget)
		{
		DoCmdGetCurrentTarget(aSection);
		}
	else if (aCommand == KCmdGetCurrentSource)
		{
		DoCmdGetCurrentSource(aSection);
		}
	else if (aCommand == KCmdBytesTransferredByCopyStep)
		{
		DoCmdBytesTransferredByCopyStep(aSection);
		}
	else if(aCommand == KCmdCurrentEntry)
		{
		DoCmdCurrentEntryL(aSection);
		}
	else if(aCommand == KCmdAbbreviatedPath)
		{
		DoCmdAbbreviatedPath(aSection);
		}
	else if(aCommand == KCmdFullPath)
		{
		DoCmdFullPath(aSection);
		}
	else if(aCommand == KCmdGetLastError)
		{
		DoCmdGetLastError(aSection);
		}
	else if(aCommand == KCmdGetMoreInfoAboutError)
		{
		DoCmdGetMoreInfoAboutError(aSection);
		}
	return retVal;
	}

void CT_FileManData::DoCleanup()
	{
	INFO_PRINTF1(_L("Doing cleanup"));
	
	if (iFileMan)
		{
		delete(iFileMan);
		iFileMan = NULL;
		}
	ClearHistory();
	}
	
/**	Inform the observer that an operation is about to start **/
MFileManObserver::TControl CT_FileManData::NotifyFileManStarted()
	{		
	THistoryData *record = new THistoryData();
	CreateHistoryRecord(*record);
	iStartedHistory.Append(record);
	if(record->iLastError != KErrNone)
		{
		if(iAsyncCall)
			{
			SetAsyncError(iAsyncErrorIndex, record->iLastError);
			iAsyncCall = EFalse;
			}
		else
			{
			SetError(record->iLastError);
			}
		}
	TControl ret = EContinue;	
	//Check if we need to return TControl value specified in INI.
	if(iUseTControl && iObserverNotifyType == ENotifyStarted)
		{
		TBuf<KMaxFileNameLength> buffer;
		buffer.Format(KPattern(), &iNotifyFileName);
		//Check if we need to return TControl for this file.
		if(record->iCurrentSource.Match(buffer) != KErrNotFound)
			{
			iUseTControl = EFalse;
			ret = iTControl;
			}
		}
	return ret;
	}
	
/**	Informs the observer that an operation, i.e. a copy or a move, is proceeding.	**/	
MFileManObserver::TControl CT_FileManData::NotifyFileManOperation()
	{	
	THistoryData *record = new THistoryData();
	CreateHistoryRecord(*record);
	iOperationHistory.Append(record);
	if(record->iLastError != KErrNone)
		{
		if(iAsyncCall)
			{
			SetAsyncError(iAsyncErrorIndex, record->iLastError);
			iAsyncCall = EFalse;
			}
		else
			{
			SetError(record->iLastError);
			}
		}
	TControl ret = EContinue;
	//Check if we need to return TControl value specified in INI.
	if(iUseTControl && iObserverNotifyType == ENotifyOperation)
		{
		TBuf<KMaxFileNameLength> buffer;
		buffer.Format(KPattern(), &iNotifyFileName);
		//Check if we need to return TControl for this file.
		if(record->iCurrentSource.Match(buffer) != KErrNotFound)
			{
			iUseTControl = EFalse;
			ret = iTControl;
			}
		}
	return ret;
	}
	
/**	Informs the observer that an operation is complete.	**/	
MFileManObserver::TControl CT_FileManData::NotifyFileManEnded()
	{
	THistoryData *record = new THistoryData();
	CreateHistoryRecord(*record);
	iEndedHistory.Append(record);
	if(record->iLastError != KErrNone)
		{
		if(iAsyncCall)
			{
			SetAsyncError(iAsyncErrorIndex, record->iLastError);
			iAsyncCall = EFalse;
			}
		else
			{
			SetError(record->iLastError);
			}
		}
	TControl ret = EContinue;
	//Check if we need to return TControl value specified in INI.
	if(iUseTControl && iObserverNotifyType == ENotifyEnded)
		{
		TBuf<KMaxFileNameLength> buffer;
		buffer.Format(KPattern(), &iNotifyFileName);
		//Check if we need to return TControl for this file.
		if(record->iCurrentSource.Match(buffer) != KErrNotFound)
			{
			iUseTControl = EFalse;
			ret = iTControl;
			}
		}
	return ret; 
	}

void CT_FileManData::DoCmdNewL(const TDesC& aSection)
	{	
	DoCleanup();
	TBool useObserver = EFalse;
	
	GET_OPTIONAL_BOOL_PARAMETER(KUseObserver, aSection, useObserver);
	
	TPtrC	rfsObjectName;
	RFs*	rfsObject = NULL;
	if (GET_MANDATORY_STRING_PARAMETER(KRFsObject, aSection, rfsObjectName))
		{
		rfsObject = (RFs*)GetDataObjectL(rfsObjectName);
		}
	
	TInt err = KErrNone;
	if(useObserver)
		{
		INFO_PRINTF1(_L("CFileMan::NewL(RFs, MFileManObserver)"));
		TRAP(err, iFileMan = CFileMan::NewL(*rfsObject, iFileManObserver));
		}
	else
		{
		INFO_PRINTF1(_L("CFileMan::NewL(RFs)"));
		TRAP(err, iFileMan = CFileMan::NewL(*rfsObject));
		}
	if (err != KErrNone)
		{
		ERR_PRINTF1(_L("CFileMan object is not created"));
		SetBlockResult(EFail);
		}
	}
	
void CT_FileManData::DoCmdAttribsL(const TDesC& aSection, TInt aAsyncErrorIndex)
	{
	INFO_PRINTF1(_L("Setting attributes!"));
	
	TBool dataOk = ETrue;
	
	//Reading path for file or files.	
	TPtrC	fileName;
	if (!GET_MANDATORY_STRING_PARAMETER(KFileName, aSection, fileName))
		{
		dataOk = EFalse;
		}
	
	//Reading new TTime from ini
	TPtrC inputTime;
	TTime iniTime;
	if(GET_MANDATORY_STRING_PARAMETER(KTime, aSection, inputTime))
		{	
		TInt err = iniTime.Set(inputTime);
		if (err != KErrNone)
			{
			ERR_PRINTF3(_L("Cannot convert (%S) to time. Error: %d"), &inputTime ,err);
			dataOk = EFalse;
			SetBlockResult(EFail);
			}
		}
	else
		{
		dataOk = EFalse;
		}
		
	//Reading Async parameter (True/False)	
	TBool async = EFalse;
	if(!GET_MANDATORY_BOOL_PARAMETER(KAsync, aSection, async))
		{
		dataOk = EFalse;
		}
	//Read SetMask attribute
	TUint setMask;
	if(!FileserverUtil::GetAttMask(*this, aSection, KSetMask(), setMask))
		{
		dataOk = EFalse;
		}
		
	//Read ClearMask attribute
	TUint clearMask;
	if(!FileserverUtil::GetAttMask(*this, aSection, KClearMask(), clearMask))
		{
		dataOk = EFalse;
		}
		
	//Read operation TSwitch
	TUint operation;
	if(!GetOperationFromConfig(KOperation(), aSection, operation))
		{
		dataOk = EFalse;
		}
	if(dataOk)
		{
		TInt error = KErrNone;
		if(async)
			{
			CActiveCallback* active = CActiveCallback::NewLC(*this);
			iAttribs.AppendL(active);
			CleanupStack::Pop(active);
			error = iFileMan->Attribs(fileName, setMask, clearMask, iniTime, operation, active->iStatus);
			if(error == KErrNone)
				{
				active->Activate(aAsyncErrorIndex);
				iAsyncErrorIndex = aAsyncErrorIndex;
				iAsyncCall = ETrue;
				IncOutstanding();
				}
			}
		else
			{
			error = iFileMan->Attribs(fileName, setMask, clearMask, iniTime, operation);
			}
		if (error != KErrNone)
			{
			ERR_PRINTF3(_L("Attribs(%S) Error: %d"), &fileName, error);
			SetError(error);
			}
		else
			{
			INFO_PRINTF2(_L("Attribs operation on (%S) is successfull!"), &fileName);
			}
		}
	}
void CT_FileManData::DoCmdCopyL(const TDesC& aSection, TInt aAsyncErrorIndex)
	{
	TBool clearHistory = EFalse;
	GET_OPTIONAL_BOOL_PARAMETER(KClearHistory, aSection, clearHistory);
	if(clearHistory)
		{
		ClearHistory();
		}
	TBool setTControl = EFalse;
	GET_OPTIONAL_BOOL_PARAMETER(KSetTcontrol, aSection, setTControl);
	if(setTControl)
		{
		ReadTControl(aSection);
		}
	
	INFO_PRINTF1(_L("Coping files!"));	
	TBool dataOk = ETrue;
	TPtrC oldName;
	TPtrC rfileObjectName;
	RFile*	rfileObject = NULL;
	
	if (!GET_OPTIONAL_STRING_PARAMETER(KOldName, aSection, oldName))
		{
		if (GET_OPTIONAL_STRING_PARAMETER(KRFileObject, aSection, rfileObjectName))
			{
			rfileObject = (RFile*)GetDataObjectL(rfileObjectName);
			}
		else
			{
			ERR_PRINTF1(_L("Cannot read \"oldname\" or \"rfileObject\" arguments!"));
			SetBlockResult(EFail);
			dataOk = EFalse;
			}
		}
		
	TPtrC newName;
	if (!GET_MANDATORY_STRING_PARAMETER(KNewName, aSection, newName))
		{
		dataOk = EFalse;
		}
		
	TUint operation;
	if (!GetOperationFromConfig(KOperation, aSection, operation))
		{
		dataOk = EFalse;
		}
	TBool async;
	if (!GET_MANDATORY_BOOL_PARAMETER(KAsync, aSection, async))
		{
		dataOk = EFalse;
		}
		
	if(dataOk)
		{
		TInt error = KErrNone;
		if(async)
			{
			CActiveCallback* active = CActiveCallback::NewLC(*this);
			iCopy.AppendL(active);
			CleanupStack::Pop(active);
			if(rfileObject)
				{
				error = iFileMan->Copy(*rfileObject, newName, operation, active->iStatus);
				}
			else
				{
				error = iFileMan->Copy(oldName, newName, operation, active->iStatus);	
				}
			if(error == KErrNone)
				{
				active->Activate(aAsyncErrorIndex);
				iAsyncErrorIndex = aAsyncErrorIndex;
				iAsyncCall = ETrue;
	            IncOutstanding();
				}
			}
		else
			{
   			if(rfileObject)
   				{
   				error = iFileMan->Copy(*rfileObject, newName, operation);	
   				}
   			else
   				{
   				error = iFileMan->Copy(oldName, newName, operation);
   				}
			}
		if (error != KErrNone)
			{
			ERR_PRINTF2(_L("Copy(), Error: %d"), error);
			SetError(error);
			}
		else
			{
			INFO_PRINTF1(_L("Copy() operation is successfully!"));
			}	
		}
	}
		
void CT_FileManData::DoCmdDeleteL(const TDesC& aSection, TInt aAsyncErrorIndex)
	{
	TBool clearHistory = EFalse;
	GET_OPTIONAL_BOOL_PARAMETER(KClearHistory, aSection, clearHistory);
	if(clearHistory)
		{
		ClearHistory();
		}
	TBool setTControl = EFalse;
	GET_OPTIONAL_BOOL_PARAMETER(KSetTcontrol, aSection, setTControl);
	if(setTControl)
		{
		ReadTControl(aSection);
		}
		
	INFO_PRINTF1(_L("Deleting files!"));
	
	TBool dataOk = ETrue;
	TPtrC	fileName;
	if (GET_MANDATORY_STRING_PARAMETER(KFileName, aSection, fileName))
		{
		if(fileName == KNullDesCStr)
			{
			fileName.Set(KNullDesC);	
			}
		}
	else
		{
		dataOk = EFalse;
		}
	TUint operation;
	if(!GetOperationFromConfig(KOperation, aSection, operation))
		{
		dataOk = EFalse;
		}
	TBool async = EFalse;
	if (!GET_MANDATORY_BOOL_PARAMETER(KAsync, aSection, async))
		{
		dataOk = EFalse;
		}
	if(dataOk)
		{
		TInt error = KErrNone;
		if(async)
			{
			CActiveCallback* active = CActiveCallback::NewLC(*this);
			iDelete.AppendL(active);
		    CleanupStack::Pop(active);
		    error = iFileMan->Delete(fileName, operation, active->iStatus);
			if (error == KErrNone)
				{
				active->Activate(aAsyncErrorIndex);
				iAsyncErrorIndex = aAsyncErrorIndex;
				iAsyncCall = ETrue;
	            IncOutstanding();
				}
			}
		else
			{
			error = iFileMan->Delete(fileName, operation);
			}
			
		if (error != KErrNone)
			{
			ERR_PRINTF3(_L("Delete (%S), Error: %d"), &fileName, error);
			SetError(error);
			}
		else
			{
			INFO_PRINTF2(_L("Delete (%S) operation is successfully!"), &fileName);
			}
		}
	}
	
void CT_FileManData::DoCmdMoveL(const TDesC& aSection, TInt aAsyncErrorIndex)
	{
	TBool clearHistory = EFalse;
	GET_OPTIONAL_BOOL_PARAMETER(KClearHistory, aSection, clearHistory);
	if(clearHistory)
		{
		ClearHistory();
		}
	TBool setTControl = EFalse;
	GET_OPTIONAL_BOOL_PARAMETER(KSetTcontrol, aSection, setTControl);
	if(setTControl)
		{
		ReadTControl(aSection);
		}
		
	INFO_PRINTF1(_L("Moving files!"));
	
	TBool	dataOk = ETrue;
	TPtrC	fileFrom;
	if (!GET_MANDATORY_STRING_PARAMETER(KFileFrom, aSection, fileFrom))
		{
		dataOk = EFalse;
		}
		
	TPtrC	fileTo;
	if (!GET_MANDATORY_STRING_PARAMETER(KFileTo, aSection, fileTo))
		{
		dataOk = EFalse;	
		}
	TBool	async;
	if (!GET_MANDATORY_BOOL_PARAMETER(KAsync, aSection, async))
		{
		dataOk = EFalse;	
		}
	TUint operation;
	if (!GetOperationFromConfig(KOperation, aSection, operation))
		{
		dataOk = EFalse;	
		}
	if(dataOk)
		{
		TInt error = KErrNone;
		if(async)
			{
			CActiveCallback*	active = CActiveCallback::NewLC(*this);
			iMove.AppendL(active);
	        CleanupStack::Pop(active);	
	        error = iFileMan->Move(fileFrom, fileTo, operation, active->iStatus);
	        if(error == KErrNone)
	        	{
	        	active->Activate(aAsyncErrorIndex);
				iAsyncErrorIndex = aAsyncErrorIndex;
				iAsyncCall = ETrue;
	            IncOutstanding();
	        	}
			}
		else
			{
			error = iFileMan->Move(fileFrom, fileTo, operation);
			}
		if (error != KErrNone)
			{
			ERR_PRINTF2(_L("Move(), Error: %d"), error);
			SetError(error);
			}
		else
			{
			INFO_PRINTF1(_L("Move() operation is successfully!"));
			}
		}	
	}
		
void CT_FileManData::DoCmdRenameL(const TDesC& aSection, TInt aAsyncErrorIndex)
	{
	TBool clearHistory = EFalse;
	GET_OPTIONAL_BOOL_PARAMETER(KClearHistory, aSection, clearHistory);
	if(clearHistory)
		{
		ClearHistory();
		}
	TBool setTControl = EFalse;
	GET_OPTIONAL_BOOL_PARAMETER(KSetTcontrol, aSection, setTControl);
	if(setTControl)
		{
		ReadTControl(aSection);
		}
	INFO_PRINTF1(_L("Renaming files!"));
		
	TBool dataOk = ETrue;
	
	//Reading Old Name
	TPtrC	oldName;
	if (!GET_MANDATORY_STRING_PARAMETER(KOldName, aSection, oldName))
		{
		dataOk = EFalse;
		}
		
	//Reading New Name
	TPtrC	newName;
	if (!GET_MANDATORY_STRING_PARAMETER(KNewName, aSection, newName))
		{
		dataOk = EFalse;
		}
		
	//Rading TSwitch - Operation
	TUint operation;
	if (!GetOperationFromConfig(KOperation(), aSection, operation))
		{
		dataOk = EFalse;
		}
	//Reading async
	TBool async;
	if (!GET_MANDATORY_BOOL_PARAMETER(KAsync, aSection, async))
		{
		dataOk = EFalse;
		}
	if(dataOk)
		{
		TInt error = KErrNone;
		if(async)
			{
			CActiveCallback* active = CActiveCallback::NewLC(*this);
			iRename.AppendL(active);
			CleanupStack::Pop(active);
			error = iFileMan->Rename(oldName, newName, operation, active->iStatus);
			if(error == KErrNone)	
				{
				active->Activate(aAsyncErrorIndex);
				iAsyncErrorIndex = aAsyncErrorIndex;
				iAsyncCall = ETrue;
				IncOutstanding();
				}			
			}
		else
			{
			error = iFileMan->Rename(oldName, newName, operation);
			}
		if (error != KErrNone)
			{
			ERR_PRINTF2(_L("Rename() Error: %d"), error);
			SetError(error);
			}
		else
			{
			INFO_PRINTF1(_L("Rename() operation is successfully!"));
			}
		}	
	}
		
void CT_FileManData::DoCmdRmDirL(const TDesC& aSection, TInt aAsyncErrorIndex)
	{
	INFO_PRINTF1(_L("Removing directory!"));
	
	TBool	dataOk = ETrue;
	TPtrC	path;
	
	if (!GET_MANDATORY_STRING_PARAMETER(KPath, aSection, path))
		{
		dataOk = EFalse;
		}
		
	TBool async = EFalse;
	if (!GET_MANDATORY_BOOL_PARAMETER(KAsync, aSection, async))
		{
		dataOk = EFalse;
		}
		
	if(dataOk)
		{
		TInt error = KErrNone;
		if(async)
			{
			CActiveCallback* active = CActiveCallback::NewLC(*this);
			iRmDir.AppendL(active);
			CleanupStack::Pop(active);
			error = iFileMan->RmDir(path, active->iStatus);
			if(error == KErrNone)
				{
				active->Activate(aAsyncErrorIndex);
				iAsyncErrorIndex = aAsyncErrorIndex;
				iAsyncCall = ETrue;
				IncOutstanding();
				}
			}
		else
			{
			error = iFileMan->RmDir(path);
			}
		if (error != KErrNone)
			{
			ERR_PRINTF3(_L("RmDir(%S), Error: %d"), &path, error);
			SetError(error);
			}
		else
			{
			INFO_PRINTF2(_L("Callled RmDir(%S)"), &path);
			}
		}
	}
	
void CT_FileManData::DoCmdSetObserver()
	{
	INFO_PRINTF1(_L("Setting observer"));
	
	iFileMan->SetObserver(this);
	}
	
void CT_FileManData::DoCmdCurrentAction(const TDesC& aSection)
	{
	TBool readHistory = EFalse;
	GET_OPTIONAL_BOOL_PARAMETER(KReadHistory, aSection, readHistory);
	CFileMan::TAction currentAction = CFileMan::ENone;
	TBool found = ETrue;
	if(readHistory)
		{
		/** Get needed history array **/
		RPointerArray<THistoryData>* history = GetHistoryDataByType(aSection);
		if(history)
			{
			CFileMan::TAction expectedAction;
			found = EFalse;
			if(GetActionFromConfig(KCurrentAction(), aSection, expectedAction))
				{
				CFileMan::TAction action;
				TInt count = history->Count();
				/** Search for expected TAction in history **/
				for(TInt i = 0; (i < count) && (!found); i++)
					{
					action = ((*history)[i])->iCurrentAction;
					if( action == expectedAction)
						{
						currentAction = action;
						found = ETrue;
						}
					}
				if(!found)
					{
					TPtrC expectedActionStr;
					ConvertActionToString(expectedAction, expectedActionStr);
					ERR_PRINTF2(_L("CurrentAction() %S not found in history!"), &expectedActionStr);
					SetBlockResult(EFail);
					}
				}
			else
				{
				ERR_PRINTF2(_L("Cannot read %S"), &KCurrentAction());
				SetBlockResult(EFail);
				}
			}
		}
	else
		{
		currentAction = iFileMan->CurrentAction();	
		}
		
	if(found)
		{
		TPtrC actionStr;
		ConvertActionToString(currentAction, actionStr);
		
		CFileMan::TAction expectedAction;
		if(GetActionFromConfig(KCurrentAction(), aSection, expectedAction))
			{
			TPtrC expectedActionStr;
			ConvertActionToString(expectedAction, expectedActionStr);
			if(expectedAction != currentAction)
				{
				ERR_PRINTF3(_L("CurrentAction(): %S != %S Expected Action"), &actionStr, &expectedActionStr);			
				SetBlockResult(EFail);
				}
			else
				{
				INFO_PRINTF3(_L("CurrentAction(): %S == %S Expected Action"), &actionStr, &expectedActionStr);			
				}
			}
		else
			{
			INFO_PRINTF2(_L("CurrentAction: %S"), &actionStr);
			}
		}
	}
	
void CT_FileManData::DoCmdGetCurrentTarget(const TDesC& aSection)
	{
	TBool readHistory = EFalse;
	GET_OPTIONAL_BOOL_PARAMETER(KReadHistory, aSection, readHistory);
	TFileName target;
	TBool found = ETrue;
	if(readHistory)
		{
		/** Get needed history array **/
		RPointerArray<THistoryData>* history = GetHistoryDataByType(aSection);
		if(history)
			{
			TPtrC expectedTarget;
			found = EFalse;
			if(GET_MANDATORY_STRING_PARAMETER(KTarget, aSection, expectedTarget))
				{
				TInt count = history->Count();
				/** Search for expected target in history **/
				for(TInt i = 0; (!found) && (i < count); i++)
					{		
					if( ((*history)[i])->iCurrentTarget == expectedTarget)
						{
						target = ((*history)[i])->iCurrentTarget;
						found = ETrue;
						}
					}
				if(!found)
					{
					ERR_PRINTF2(_L("GetCurrentTarget() %S not found in history!"), &expectedTarget);
					SetBlockResult(EFail);
					}
				}
			}
		}
	else
		{
		iFileMan->GetCurrentTarget(target);
		}
	if(found)
		{
		TPtrC expectedTarget;
		if(GET_OPTIONAL_STRING_PARAMETER(KTarget, aSection, expectedTarget))
			{
			if(target == expectedTarget)
				{
				INFO_PRINTF3(_L("GetCurrentTarget() %S == %S ExpectedResult"), &target, &expectedTarget);
				}
			else
				{
				ERR_PRINTF3(_L("GetCurrentTarget() %S != %S ExpectedResult"), &target, &expectedTarget);
				SetBlockResult(EFail);
				}
			
			}
		else
			{
			INFO_PRINTF2(_L("GetCurrentTarget() %S"), &target);	
			}
		}
	}
void CT_FileManData::DoCmdGetCurrentSource(const TDesC& aSection)
	{
	TBool readHistory = EFalse;	
	GET_OPTIONAL_BOOL_PARAMETER(KReadHistory, aSection, readHistory);
	TFileName source;
	TBool found = ETrue;
	if(readHistory)
		{
		/** Get needed history array **/
		RPointerArray<THistoryData>* history = GetHistoryDataByType(aSection);
		if(history)
			{
			TPtrC expectedSource;
			found = EFalse;
			if(GET_MANDATORY_STRING_PARAMETER(KSource, aSection, expectedSource))
				{
				TInt count = history->Count();
				/** Search for expected source in history **/
				for(TInt i = 0; (!found) && (i < count); i++)
					{				
					if( (*history)[i]->iCurrentSource == expectedSource)
						{
						source = (*history)[i]->iCurrentSource;
						found = ETrue;
						}
					}
				if(!found)
					{
					ERR_PRINTF2(_L("GetCurrentSource() %S not found in history!"), &expectedSource);
					SetBlockResult(EFail);
					}
				}
			}
		}
	else
		{
		iFileMan->GetCurrentSource(source);
		}
		
	if (found)
		{
		TPtrC expectedSource;
		if(GET_OPTIONAL_STRING_PARAMETER(KSource, aSection, expectedSource))
			{
			if(source == expectedSource)
				{
				INFO_PRINTF3(_L("GetCurrentSource() %S == %S ExpectedResult"), &source, &expectedSource);
				}
			else
				{
				ERR_PRINTF3(_L("GetCurrentSource() %S != %S ExpectedResult"), &source, &expectedSource);
				SetBlockResult(EFail);
				}
			
			}
		else
			{
			INFO_PRINTF2(_L("GetCurrentSource() %S"), &source);	
			}
		}
		
	}
void CT_FileManData::DoCmdBytesTransferredByCopyStep(const TDesC& aSection)
	{
	TBool readHistory = EFalse;
	GET_OPTIONAL_BOOL_PARAMETER(KReadHistory, aSection, readHistory);
	TInt bytes = 0;
	TBool found = ETrue;
	if(readHistory)
		{
		/** Get needed history array **/
		RPointerArray<THistoryData>* history = GetHistoryDataByType(aSection);
		if(history)
			{
			TInt expectedBytes;
			found = EFalse;
			if(GET_MANDATORY_INT_PARAMETER(KBytes, aSection, expectedBytes))
				{
				TBool totalBytes = EFalse;
				GET_OPTIONAL_BOOL_PARAMETER(KTotalBytes, aSection, totalBytes);
				TInt count = history->Count();
				TInt bytesTemp;
				/** Search for expected transferred bytes in history **/
				for(TInt i = 0; (!found) && (i < count); i++)
					{
					bytesTemp = ((*history)[i])->iBytesTransferred;
					if(totalBytes)
						{
						bytes +=bytesTemp;
						}
					else
						{
						if( bytesTemp == expectedBytes)
							{
							bytes = bytesTemp;
							found = ETrue;
							}
						}
					}
				if(totalBytes)
					{
					found = ETrue;
					}
				if(!found)
					{
					ERR_PRINTF2(_L("BytesTransferredByCopyStep() %d not found in history!"), expectedBytes);
					SetBlockResult(EFail);
					}
				}
			}
		}
	else
		{
		bytes = iFileMan->BytesTransferredByCopyStep();
		}
	if (found)
		{
		TInt expectedBytes;	
		if(GET_OPTIONAL_INT_PARAMETER(KBytes, aSection, expectedBytes))
			{		
			if(expectedBytes != bytes)
				{
				ERR_PRINTF3(_L("BytesTransferredByCopyStep(): %d != %d Expected Bytes"), bytes, expectedBytes);
				SetBlockResult(EFail);
				}
			else
				{
				INFO_PRINTF3(_L("BytesTransferredByCopyStep(): %d == %d Expected Bytes"), bytes, expectedBytes);
				}
			}
		else
			{
			INFO_PRINTF2(_L("BytesTransferredByCopyStep(): %d"), bytes);
			}
		}
	}
void CT_FileManData::DoCmdCurrentEntryL(const TDesC& aSection)
	{
	
	TEntry* entryObject = NULL;
	TBool found = ETrue;
	TBool readHistory = EFalse;	
	GET_OPTIONAL_BOOL_PARAMETER(KReadHistory, aSection, readHistory);
	if(readHistory)
		{
		/** Get needed history array **/
		RPointerArray<THistoryData>* history = GetHistoryDataByType(aSection);
		if(history)
			{
			TPtrC expectedName;
			found = EFalse;
			if(GET_MANDATORY_STRING_PARAMETER(KName, aSection, expectedName))
				{
				TInt count = history->Count();
				TEntry entry;
				/** Search for expected TEntry.iName in history **/
				for(TInt i = 0; (!found) && (i < count); i++)
					{
					entry = ((*history)[i])->iCurrentEntry;
					if( entry.iName == expectedName)
						{
						entryObject = &entry;
						found = ETrue;
						}
					}
				if(!found)
					{
					ERR_PRINTF1(_L("CurrentEntry() not found in history!"));
					SetBlockResult(EFail);
					}
				}	
			}
		}
	else
		{
		*entryObject = iFileMan->CurrentEntry();
		}
	if(found)
		{
		if(!FileserverUtil::VerifyTEntryDataFromIniL(*this, aSection, *entryObject))
			{
			SetBlockResult(EFail);	
			}
		}
		
	}
void CT_FileManData::DoCmdAbbreviatedPath(const TDesC& aSection)
	{
	TBool readHistory = EFalse;	
	GET_OPTIONAL_BOOL_PARAMETER(KReadHistory, aSection, readHistory);
	TPtrC path;
	TBool found = ETrue;
	if(readHistory)
		{
		/** Get needed history array **/
		RPointerArray<THistoryData>* history = GetHistoryDataByType(aSection);
		if(history)
			{
			TPtrC expectedPath;
			found = EFalse;
			if(GET_MANDATORY_STRING_PARAMETER(KPath, aSection, expectedPath))
				{
				TInt count = history->Count();
				/** Search for expected abbreviated path in history **/
				for(TInt i = 0; (!found) && (i < count); i++)
					{	
					if( ((*history)[i])->iAbbreviatedPath == expectedPath)
						{
						path.Set(((*history)[i])->iAbbreviatedPath);
						found = ETrue;
						}
					}
				if(!found)
					{
					ERR_PRINTF2(_L("AbbreviatedPath() %S not found in history!"), &expectedPath);
					SetBlockResult(EFail);
					}
				}
			}
		}
	else
		{
		path.Set(iFileMan->AbbreviatedPath());
		}
		
	if (found)
		{
		TPtrC expectedPath;
		if(GET_OPTIONAL_STRING_PARAMETER(KPath, aSection, expectedPath))
			{		
			if(expectedPath.Compare(path) != 0)
				{
				ERR_PRINTF3(_L("AbbreviatedPath(): %S != %S Expected Path"), &path, &expectedPath);
				SetBlockResult(EFail);
				}
			else
				{
				INFO_PRINTF3(_L("AbbreviatedPath(): %S == %S Expected Path"), &path, &expectedPath);
				}
			}
		else
			{
			INFO_PRINTF2(_L("AbbreviatedPath(): %S"), &path);
			}
		}
	}
void CT_FileManData::DoCmdFullPath(const TDesC& aSection)
	{
	TBool readHistory = EFalse;	
	GET_OPTIONAL_BOOL_PARAMETER(KReadHistory, aSection, readHistory);
	TPtrC fullPath;
	TBool found = ETrue;
	if(readHistory)
		{
		/** Get needed history array **/
		RPointerArray<THistoryData>* history = GetHistoryDataByType(aSection);
		if(history)
			{
			TPtrC expectedPath;
			found = EFalse;
			if(GET_MANDATORY_STRING_PARAMETER(KPath, aSection, expectedPath))
				{
				TInt count = history->Count();
				/** Search for expected full path in history **/
				for(TInt i = 0; (!found) && (i < count); i++)
					{	
					if( ((*history)[i])->iFullPath == expectedPath)
						{
						fullPath.Set(((*history)[i])->iFullPath);
						found = ETrue;
						}
					}
				if(!found)
					{
					ERR_PRINTF2(_L("FullPath() %S not found in history!"), &expectedPath);
					SetBlockResult(EFail);
					}	
				}
			}
		}
	else
		{
		fullPath.Set(iFileMan->FullPath());
		}
	if(found)
		{
		TPtrC expectedPath;
		if(GET_OPTIONAL_STRING_PARAMETER(KPath, aSection, expectedPath))
			{		
			if(expectedPath.Compare(fullPath) != 0)
				{
				ERR_PRINTF3(_L("FullPath(): %S != %S Expected Path"), &fullPath, &expectedPath);
				SetBlockResult(EFail);
				}
			else
				{
				INFO_PRINTF3(_L("FullPath(): %S == %S Expected Path"), &fullPath, &expectedPath);
				}
			}
		else
			{
			INFO_PRINTF2(_L("FullPath(): %S"), &fullPath);
			}
		}
	}
void CT_FileManData::DoCmdGetLastError(const TDesC& aSection)
	{
	TBool readHistory = EFalse;	
	GET_OPTIONAL_BOOL_PARAMETER(KReadHistory, aSection, readHistory);
	TInt lastError = KErrNone;
	TBool found = ETrue;
	if(readHistory)
		{
		/** Get needed history array **/
		RPointerArray<THistoryData>* history = GetHistoryDataByType(aSection);
		if(history)
			{
			TInt expectedError;
			found = EFalse;
			if(GET_MANDATORY_INT_PARAMETER(KError, aSection, expectedError))
				{
				TInt count = history->Count();
				TInt err;
				/** Search for expected error in history **/
				for(TInt i = 0; (!found) && (i < count); i++)
					{	
					err = (*history)[i]->iLastError;			
					if( err == expectedError)
						{
						lastError = err;
						found = ETrue;
						}
					}
				if(!found)
					{
					ERR_PRINTF2(_L("GetLastError() %d not found in history!"), expectedError);
					SetBlockResult(EFail);
					}
				}
			}
		}
	else
		{
		lastError = iFileMan->GetLastError();
		}
	if (found)
		{
		TInt expectedError;	
		if(GET_OPTIONAL_INT_PARAMETER(KError, aSection, expectedError))
			{		
			if(expectedError != lastError)
				{
				ERR_PRINTF3(_L("GetLastError(): %d != %d Expected Error"), lastError, expectedError);
				SetBlockResult(EFail);
				}
			else
				{
				INFO_PRINTF3(_L("GetLastError(): %d == %d Expected Error"), lastError, expectedError);
				}
			}
		else
			{
			INFO_PRINTF2(_L("GetLastError(): %d"), lastError);
			}
		}
	}
		
void CT_FileManData::DoCmdGetMoreInfoAboutError(const TDesC& aSection)
	{
	TBool readHistory = EFalse;	
	GET_OPTIONAL_BOOL_PARAMETER(KReadHistory, aSection, readHistory);
	TFileManError lastError;
	TBool found = ETrue;
	if(readHistory)
		{
		/** Get needed history array **/
		RPointerArray<THistoryData>* history = GetHistoryDataByType(aSection);
		if(history)
			{
			TFileManError expectedError;
			found = EFalse;
			if(GetFileManErrorFromConfig(KError, aSection, expectedError))
				{
				TInt count = history->Count();
				TFileManError error;
				/** Search for expected error in history **/
				for(TInt i = 0; (!found) && (i < count); i++)
					{
					error = (*history)[i]->iMoreInfoAboutError;
					if( (error == expectedError))
						{
						lastError = error;
						found = ETrue;
						}
					}
				if(!found)
					{
					ERR_PRINTF2(_L("GetMoreInfoAboutError() %S not found in history!"), expectedError);
					SetBlockResult(EFail);
					}
				}
			}
		}
	else
		{
		lastError = iFileMan->GetMoreInfoAboutError();
		}
	if (found)
		{
		TPtrC errorStr;
		ConvertFileManErrorToString(lastError, errorStr);
		TFileManError expectedError;
		if(GetFileManErrorFromConfig(KError, aSection, expectedError))
			{
			TPtrC expectedErrorStr;
			ConvertFileManErrorToString(expectedError, expectedErrorStr);
			
			if(expectedError != lastError)
				{
				ERR_PRINTF3(_L("GetMoreInfoAboutError(): %S != %S Expected Error"), &errorStr, &expectedErrorStr);
				SetBlockResult(EFail);
				}
			else
				{
				INFO_PRINTF3(_L("GetMoreInfoAboutError(): %S == %S Expected Error"), &errorStr, &expectedErrorStr);
				}
			}
		else
			{
			INFO_PRINTF2(_L("GetMoreInfoAboutError(): %S"), &errorStr);
			}
		}
		
	}
void CT_FileManData::RunL(CActive* aActive, TInt aIndex)
/**
 Virtual RunL - Called on completion of an asynchronous command
 @internalComponent
 @see MActiveCallback
 @param aActive Active Object that RunL has been called on
 @pre N/A
 @post N/A
 @leave system wide error code
*/
	{
	INFO_PRINTF1(_L("CT_FileManData::RunL Called"));
	TBool	foundActiveObject = EFalse;
	TInt	index=0;
	TInt	count=0;
	TBool	completed=ETrue;
	
	count = iAttribs.Count();
	for( index=0; (index<count) && (!foundActiveObject); ++index )
 		{
 		if( aActive == iAttribs[index] )
			{   
			INFO_PRINTF1(_L("RunL iAttribs called"));
			foundActiveObject = ETrue;
			iAttribs.Remove(index);
	 		}
		}

	count = iCopy.Count();
	for( index=0; (index<count) && (!foundActiveObject); ++index )
 		{
 		if( aActive == iCopy[index] )
			{						    
			INFO_PRINTF1(_L("RunL iCopy called"));
			foundActiveObject = ETrue;
			iCopy.Remove(index);
	 		}
		}	
	
	count = iDelete.Count();
	for( index=0; (index<count) && (!foundActiveObject); ++index )
 		{
 		if( aActive == iDelete[index] )
			{						    
			INFO_PRINTF1(_L("RunL iDelete called"));
			foundActiveObject = ETrue;
			iDelete.Remove(index);
	 		}
		}
		
	count = iMove.Count();
	for( index=0; (index<count) && (!foundActiveObject); ++index )
 		{
 		if( aActive == iMove[index] )
			{						    
			INFO_PRINTF1(_L("RunL iMove called"));
			foundActiveObject = ETrue;
			iMove.Remove(index);
	 		}
		}
		
	count = iRename.Count();
	for( index=0; (index<count) && (!foundActiveObject); ++index )
 		{
 		if( aActive == iRename[index] )
			{						    
			INFO_PRINTF1(_L("RunL iRename called"));
			foundActiveObject = ETrue;
			iRename.Remove(index);
	 		}
		}	
	
	count = iRmDir.Count();
	for( index=0; (index<count) && (!foundActiveObject); ++index )
 		{
 		if( aActive == iRmDir[index] )
			{						    
			INFO_PRINTF1(_L("RunL iRmDir called"));
			foundActiveObject = ETrue;
			iRmDir.Remove(index);
	 		}
		}
	
	if( foundActiveObject )
 		{
		TInt	err = aActive->iStatus.Int();
		if( err != KErrNone )
			{
			ERR_PRINTF2(_L("RunL Error %d"), err);
			SetAsyncError( aIndex, err );
			iAsyncCall = EFalse;
			}

		if ( completed )
			{
			// Reset the outstanding request state
			DecOutstanding();
			delete aActive;
			}
		}
	else
		{
 		ERR_PRINTF1(_L("Stray RunL signal"));
 		SetBlockResult(EFail);
		}
	}
	
	
void CT_FileManData::DoCancel(CActive* aActive, TInt aIndex)
/**
 Virtual DoCancel - Request to cancel the asynchronous command
 @internalComponent
 @see - MActiveCallback
 @param aActive Active Object that DoCancel has been called on
 @pre - N/A
 @post - N/A
 @leave system wide error code
*/
	{
	INFO_PRINTF1(_L("CT_FileManData::DoCancelL Called"));
	
	TBool	foundActiveObject = EFalse;
	TInt	index=0;
	TInt	count=0;
	
	
	// See if it is in iAttribs
	count = iAttribs.Count();
	for( index=0; (index<count) && (!foundActiveObject); ++index )
 		{
 		if( aActive == iAttribs[index] )
			{  
			INFO_PRINTF1(_L("DoCancel iAttribs called"));
			foundActiveObject = ETrue;
			iAttribs.Remove(index);
	 		}
		}
	
	// See if it is in iCopy2
	count = iCopy.Count();
	for( index=0; (index<count) && (!foundActiveObject); ++index )
 		{
 		if( aActive == iCopy[index] )
			{  
			INFO_PRINTF1(_L("DoCancel iCopy called"));
			foundActiveObject = ETrue;
			iCopy.Remove(index);
	 		}
		}
				
	// See if it is in iDelete
	count = iDelete.Count();
	for( index=0; (index<count) && (!foundActiveObject); ++index )
 		{
 		if( aActive == iDelete[index] )
			{  
			INFO_PRINTF1(_L("DoCancel iDelete called"));
			foundActiveObject = ETrue;
			iDelete.Remove(index);
	 		}
		}
		
	// See if it is in iMove
	count = iMove.Count();
	for( index=0; (index<count) && (!foundActiveObject); ++index )
 		{
 		if( aActive == iMove[index] )
			{  
			INFO_PRINTF1(_L("DoCancel iMove called"));
			foundActiveObject = ETrue;
			iMove.Remove(index);
	 		}
		}
		
	// See if it is in iRename
	count = iRename.Count();
	for( index=0; (index<count) && (!foundActiveObject); ++index )
 		{
 		if( aActive == iRename[index] )
			{  
			INFO_PRINTF1(_L("DoCancel iRename called"));
			foundActiveObject = ETrue;
			iRename.Remove(index);
	 		}
		}
		
	// See if it is in iRmDir
	count = iRmDir.Count();
	for( index=0; (index<count) && (!foundActiveObject); ++index )
 		{
 		if( aActive == iRmDir[index] )
			{  
			INFO_PRINTF1(_L("DoCancel iRmDir called"));
			foundActiveObject = ETrue;
			iRmDir.Remove(index);
	 		}
		}
		
	if( foundActiveObject )
 		{
		TInt	err = aActive->iStatus.Int();
		if( err != KErrNone )
			{
			ERR_PRINTF2(_L("DoCancel Error %d"), err);
			SetAsyncError( aIndex, err );
			}

		// Reset the outstanding request state
		DecOutstanding();

		delete aActive;
		}
	else
		{
 		ERR_PRINTF1(_L("Stray DoCancel signal"));
 		SetBlockResult(EFail);
		}
	}
		
/** Reads TFileManError from INI and converts it to TFileManError type. **/	
TBool CT_FileManData::GetFileManErrorFromConfig(const TDesC& aParameterName, const TDesC& aSection, TFileManError& aError)
	{
	TPtrC errorStr;
	TBool ret = GET_OPTIONAL_STRING_PARAMETER(aParameterName, aSection, errorStr);
	if(ret)
		{
		if(errorStr == KENoExtraInformation)
			{
			aError = ENoExtraInformation;
			}
		else if(errorStr == KEInitializationFailed)
			{
			aError = EInitializationFailed;
			}
		else if (errorStr == KEScanNextDirectoryFailed)
			{
			aError = EScanNextDirectoryFailed;
			}
		else if (errorStr == KESrcOpenFailed)
			{
			aError = ESrcOpenFailed;
			}
		else if (errorStr == KETrgOpenFailed)
			{
			aError = ETrgOpenFailed;
			}
		else if (errorStr == KENoFilesProcessed)
			{
			aError = ENoFilesProcessed;
			}
		else
			{
			ret = EFalse;	
			}
		}
	return ret;	
	}

/** Converts TFileManError type to string **/
void CT_FileManData::ConvertFileManErrorToString(TFileManError& aError, TPtrC& aErrorStr)
	{
	if(aError == ENoExtraInformation)
		{
		aErrorStr.Set(KENoExtraInformation());
		}
	else if(aError == EInitializationFailed)
		{
		aErrorStr.Set(KEInitializationFailed());
		}
	else if (aError == EScanNextDirectoryFailed)
		{
		aErrorStr.Set(KEScanNextDirectoryFailed());
		}
	else if (aError == ESrcOpenFailed)
		{
		aErrorStr.Set(KESrcOpenFailed());
		}
	else if (aError == ETrgOpenFailed)
		{
		aErrorStr.Set(KETrgOpenFailed());
		}
	else if (aError == ENoFilesProcessed)
		{
		aErrorStr.Set(KENoFilesProcessed());
		}
	}
	
/** Converts CFileMan::TAction type to string **/
void CT_FileManData::ConvertActionToString(CFileMan::TAction aAction, TPtrC& aActionStr)
	{
	if (aAction == CFileMan::EAttribs)
		{
		aActionStr.Set(KEAttribs());
		}
	else if (aAction == CFileMan::ECopy)
		{
		aActionStr.Set(KECopy());
		}
	else if (aAction == CFileMan::EDelete)
		{
		aActionStr.Set(KEDelete());
		}
	else if (aAction == CFileMan::EMove)
		{
		aActionStr.Set(KEMove());
		}
	else if (aAction == CFileMan::ERename)
		{
		aActionStr.Set(KERename());
		}
	else if (aAction == CFileMan::ERmDir)
		{
		aActionStr.Set(KERmDir());
		}
	else if (aAction == CFileMan::ERenameInvalidEntry)
		{
		aActionStr.Set(KERenameInvalidEntry());
		}
	else if (aAction == CFileMan::ECopyFromHandle)
		{
		aActionStr.Set(KECopyFromHandle());
		}
	else
		{
		aActionStr.Set(KENone());
		}
		
	}
	
/** Reads CFileMan::TAction from INI and converts it to CFileMan::TAction type. **/
TBool CT_FileManData::GetActionFromConfig(const TDesC& aParameterName, const TDesC& aSection, CFileMan::TAction& aAction)
	{
	TPtrC actionStr;
	TBool ret = GET_OPTIONAL_STRING_PARAMETER(aParameterName, aSection, actionStr);
	if(ret)
		{		
		if (actionStr == KEAttribs)
			{
			aAction = CFileMan::EAttribs;
			}
		else if (actionStr == KECopy)
			{
			aAction = CFileMan::ECopy;
			}
		else if (actionStr == KEDelete)
			{
			aAction = CFileMan::EDelete;
			}
		else if (actionStr == KEMove)
			{
			aAction = CFileMan::EMove;
			}
		else if (actionStr == KERename)
			{
			aAction = CFileMan::ERename;
			}
		else if (actionStr == KERmDir)
			{
			aAction = CFileMan::ERmDir;
			}
		else if (actionStr == KERenameInvalidEntry)
			{
			aAction = CFileMan::ERenameInvalidEntry;
			}
		else if (actionStr == KECopyFromHandle)
			{
			aAction = CFileMan::ECopyFromHandle;
			}
		else if (actionStr == KENone)
			{
			aAction = CFileMan::ENone;
			}
		else
			{
			ret = EFalse;
			}
		}
		return ret;
	}
	
/** Reads CFileMan::TSwitch from INI and converts it to CFileMan::TSwitch type. **/
TBool CT_FileManData::GetOperationFromConfig(const TDesC& aParameterName, const TDesC& aSection, TUint& aSwitch)
	{
	TPtrC	operation;
	TBool	ret=GET_MANDATORY_STRING_PARAMETER(aParameterName, aSection, operation);
	if(ret)
		{	
		if (operation == KEOverWrite)
			{
			aSwitch = CFileMan::EOverWrite;
			}
		else if (operation == KERecurse)
			{
			aSwitch = CFileMan::ERecurse;
			}
		else
			{
			TInt operationInt=0;
			ret = GET_MANDATORY_INT_PARAMETER(aParameterName, aSection, operationInt);
			if (ret)
				{
				aSwitch = (CFileMan::TSwitch) operationInt;
				}
			}
		}
	return ret;	
	}
	
/** Clears all arrays with history **/
void CT_FileManData::ClearHistory()
	{
	INFO_PRINTF1(_L("Clearing history!"));
	
	iStartedHistory.ResetAndDestroy();
	iOperationHistory.ResetAndDestroy();
	iEndedHistory.ResetAndDestroy();	
	}
	
/**
* Creates a history entry.
* This method runs only from NotifyFileManStarted(), NotifyFileManOperation(), NotifyFileManEnded().
**/
void CT_FileManData::CreateHistoryRecord(THistoryData& aRecord)
	{
	TFileName source;
	iFileMan->GetCurrentSource(source);
	aRecord.iCurrentSource = source;
	
	TFileName target;
	iFileMan->GetCurrentTarget(target);
	aRecord.iCurrentTarget = target;
	
	aRecord.iCurrentEntry = iFileMan->CurrentEntry();
	aRecord.iBytesTransferred = iFileMan->BytesTransferredByCopyStep();
	aRecord.iCurrentAction = iFileMan->CurrentAction();
	aRecord.iLastError = iFileMan->GetLastError();
	aRecord.iMoreInfoAboutError = iFileMan->GetMoreInfoAboutError();
	aRecord.iFullPath.Set( iFileMan->FullPath() );
	aRecord.iAbbreviatedPath.Set( iFileMan->AbbreviatedPath() );	
	}
	
/** Reads type of notification from INI and converts it to TObserverNotifyType **/
TBool CT_FileManData::GetNotifyType(const TDesC& aParameterName, const TDesC& aSection, TObserverNotifyType& aType)
	{
	TPtrC	type;
	TBool	ret=GET_MANDATORY_STRING_PARAMETER(aParameterName, aSection, type);
	if(ret)
		{	
		if (type == KNotifyStarted)
			{
			aType = ENotifyStarted;
			}
		else if (type == KNotifyOperation)
			{
			aType = ENotifyOperation;
			}
		else if (type == KNotifyEnded)
			{
			aType = ENotifyEnded;
			}
		else
			{
			ret = EFalse;
			}
		}
	return ret;	
	}

/** Returns specific array of history using TObserverNotifyType value   **/	
RPointerArray<THistoryData>* CT_FileManData::GetHistoryDataByType(const TDesC& aSection)
	{	
	TObserverNotifyType type;
	RPointerArray<THistoryData>* history = NULL;
	//Reads history name which must be returned.
	if (GetNotifyType(KNotifyType(), aSection, type))
		{
		if(type == ENotifyStarted)
			{
			history = (RPointerArray<THistoryData>*)&iStartedHistory;
			}
		else if(type == ENotifyOperation)
			{
			history = (RPointerArray<THistoryData>*)&iOperationHistory;
			}
		else if(type == ENotifyEnded)
			{
			history = (RPointerArray<THistoryData>*)&iEndedHistory;
			}
		}
	return history;
	}
/** Reads TControl from config and converts it to TControl type  **/
TBool CT_FileManData::GetTControlFromConfig(const TDesC& aParameterName, const TDesC& aSection, TControl& aFlag)
	{
	TPtrC flag;
	TBool	ret=GET_MANDATORY_STRING_PARAMETER(aParameterName, aSection, flag);
	if(ret)
		{	
		if (flag == KEContinue)
			{
			aFlag = EContinue;
			}
		else if (flag == KEAbort)
			{
			aFlag = EAbort;
			}
		else if (flag == KECancel)
			{
			aFlag = ECancel;
			}
		else if (flag == KERetry)
			{
			aFlag = ERetry;
			}
		else
			{
			ret = EFalse;
			}
		}
	return ret;	
	}

/** Reads TControl and file name from INI  **/	
void CT_FileManData::ReadTControl(const TDesC& aSection)
	{
	TBool dataOk = ETrue;
	if(!GetNotifyType(KNotifyType(), aSection, iObserverNotifyType))
		{
			dataOk = EFalse;
		}
	TPtrC fileName;
	if(GET_MANDATORY_STRING_PARAMETER(KFileName(), aSection, fileName))
		{
		iNotifyFileName = fileName;
		}
	else
		{
		dataOk = EFalse;	
		}
	if(!GetTControlFromConfig(KFlag(), aSection, iTControl))
		{
		dataOk = EFalse;
		}
	if(dataOk)
		{
		iUseTControl = ETrue;
		}
	}