/*
* 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_FsData
*/

//	User includes
#include "T_FsData.h"
#include "T_SfSrvServer.h"
#include "DataWrapperBase.h"

/*@{*/

_LIT(KMessageSlots,							"messageSlots");
_LIT(KPath,									"path");
_LIT(KAddress,								"address");
_LIT(KType,									"type");
_LIT(KAll,									"all");
_LIT(KResources,							"resources");
_LIT(KNotify,								"notify");
_LIT(KInRom,								"inRom");
_LIT(KThreshold,							"threshold");
_LIT(KDrive,								"drive");
_LIT(KFunctionId,							"functionId");
_LIT(KAdd,									"add");
_LIT(KSub,									"sub");
_LIT(KUseFreeSpace,							"use_free_space");
_LIT(KVersionName,							"name");
_LIT(KVersionBuild,							"build");
_LIT(KVersionMajor,							"major");
_LIT(KVersionMinor,							"minor");
_LIT(KIndex,								"index");
_LIT(KParam1,								"param1");
_LIT(KParam2,								"param2");
_LIT(KFile,									"file");
_LIT(KCount,								"count");

///	Commands
_LIT(KCmdNew,								"new");
_LIT(KCmdClose,								"Close");
_LIT(KCmdDestructor,						"~");
_LIT(KCmdConnect,							"Connect");
_LIT(KCmdVersion,							"Version");
_LIT(KCmdNotifyChange,						"NotifyChange");
_LIT(KCmdNotifyChangeCancel,				"NotifyChangeCancel");
_LIT(KCmdNotifyDiskSpace,					"NotifyDiskSpace");
_LIT(KCmdNotifyDiskSpaceCancel,				"NotifyDiskSpaceCancel");
_LIT(KCmdIsRomAddress,						"IsRomAddress");
_LIT(KCmdResourceCountMarkStart,			"ResourceCountMarkStart");
_LIT(KCmdResourceCountMarkEnd,				"ResourceCountMarkEnd");
_LIT(KCmdResourceCount,						"ResourceCount");
_LIT(KCmdGetNotifyUser,						"GetNotifyUser");
_LIT(KCmdSetNotifyUser,						"SetNotifyUser");
_LIT(KCmdSetNotifyChange,					"SetNotifyChange");
_LIT(KCmdLoaderHeapFunction,				"LoaderHeapFunction");
_LIT(KCmdInitialisePropertiesFile,			"InitialisePropertiesFile");
/*@}*/

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

CT_FsData::CT_FsData()
/**
 * Protected constructor. First phase construction
 */
	{
	}

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

CT_FsData::~CT_FsData()
/**
 * Destructor.
 */
	{
	DoCleanup();

	iNotifyChange.ResetAndDestroy();
	iNotifyDiskSpace.ResetAndDestroy();
	iNotifyDismount.ResetAndDestroy();
	iStartupInitComplete.ResetAndDestroy();
	}

void CT_FsData::DoCleanup()
/**
 * Contains cleanup implementation
 */
	{
	//Deleting RFs.
	if(iFs != NULL)
		{
		INFO_PRINTF1(_L("Deleting current RFs"));
		delete iFs;
		iFs = NULL;
		}
	}

TAny* CT_FsData::GetObject()
/**
 * Return a pointer to the object that the data wraps
 *
 * @return pointer to the object that the data wraps
 */
	{
	return iFs;
	}

TUint64 CT_FsData::ThreadId()
	{
	RThread currentThread;
	return currentThread.Id().Id();
	}

TBool CT_FsData::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 entry in the ini file requiring the command to be processed
 *
 * @return ETrue if the command is processed
 */
	{
	TBool retVal = ETrue;
	if (aCommand == KCmdNew)
		{
		DoCmdNewL();
		}
	else if (aCommand == KCmdClose)
		{
		DoCmdClose();
		}
	else if (aCommand == KCmdDestructor)
		{
		DoCmdDestructor();
		}
	else if (aCommand == KCmdConnect)
		{
		DoCmdConnect(aSection);
		}
	else if (aCommand == KCmdVersion)
		{
		DoCmdVersion(aSection);
		}
	else if (aCommand == KCmdNotifyChange)
		{
		DoCmdNotifyChangeL(aSection, aAsyncErrorIndex);
		}
	else if (aCommand == KCmdNotifyChangeCancel)
		{
		DoCmdNotifyChangeCancel(aSection);
		}
	else if (aCommand == KCmdNotifyDiskSpace)
		{
		DoCmdNotifyDiskSpaceL(aSection, aAsyncErrorIndex);
		}
	else if (aCommand == KCmdNotifyDiskSpaceCancel)
		{
		DoCmdNotifyDiskSpaceCancel(aSection);
		}
	else if (aCommand == KCmdIsRomAddress)
		{
		DoCmdIsRomAddress(aSection);
		}
	else if (aCommand == KCmdResourceCountMarkStart)
		{
		DoCmdResourceCountMarkStart();
		}
	else if (aCommand == KCmdResourceCountMarkEnd)
		{
		DoCmdResourceCountMarkEnd();
		}
	else if (aCommand == KCmdResourceCount)
		{
		DoCmdResourceCount(aSection);
		}
	else if (aCommand == KCmdGetNotifyUser)
		{
		DoCmdGetNotifyUser(aSection);
		}
	else if (aCommand == KCmdSetNotifyUser)
		{
		DoCmdSetNotifyUser(aSection);
		}
	else if (aCommand == KCmdLoaderHeapFunction)
		{
		DoCmdLoaderHeapFunctionL(aSection);
		}
	else if (aCommand == KCmdSetNotifyChange)
		{
		DoCmdSetNotifyChange(aSection);
		}
	else if (aCommand == KCmdInitialisePropertiesFile)
		{
		DoCmdInitialisePropertiesFile(aSection);
		}
	else
		{
		if (!DoCommandDrivesL(aCommand, aSection, aAsyncErrorIndex))
			{
			if (!DoCommandMountsL(aCommand, aSection, aAsyncErrorIndex))
				{
				if (!DoCommandFilesL(aCommand, aSection, aAsyncErrorIndex))
					{
					retVal = EFalse;
					}
				}
			}
		}
	return retVal;
	}


void CT_FsData::DoCmdNewL()
/** Creates new RFs class instance */
	{
	INFO_PRINTF1(_L("Create new RFs class instance"));
	
	//Deletes previous RFs class instance if it was already created.
	DoCleanup();

	// do create
	TRAPD(err, iFs = new (ELeave) RFs());
	if ( err!=KErrNone )
		{
		ERR_PRINTF2(_L("new error %d"), err);
		SetError( err );
		}
	}

void CT_FsData::DoCmdClose()
/** Close RFs handle */
	{
	INFO_PRINTF1(_L("Closing RFs"));
	iFs->Close();
	}


void CT_FsData::DoCmdDestructor()
/** Destroy RFs the object */
	{
	INFO_PRINTF1(_L("Destroying the RFs object"));
	DoCleanup();
	}

void CT_FsData::DoCmdConnect(const TDesC& aSection)
/** Connects a client to the file server */
	{

	TInt	messageSlots = KFileServerDefaultMessageSlots;
	GetIntFromConfig(aSection, KMessageSlots, messageSlots);

	TInt err = iFs->Connect(messageSlots);
	INFO_PRINTF2(_L("Call Connect(messageSlots = %d)"), messageSlots);

	if ( err!=KErrNone )
		{
		ERR_PRINTF2(_L("Connect() error %d"), err);
		SetError( err );
		}
	}

void CT_FsData::DoCmdVersion(const TDesC& aSection)
/** Gets the client side version number */
	{
	
	TVersion		version=iFs->Version();
	TVersionName	versionName	= version.Name();
	INFO_PRINTF2(_L("Version name  : %S"), &versionName);
	INFO_PRINTF2(_L("Version build : %d"), (TInt)version.iBuild);
	INFO_PRINTF2(_L("Version major : %d"), (TInt)version.iMajor);
	INFO_PRINTF2(_L("Version minor : %d"), (TInt)version.iMinor);

	TPtrC	name;
	if ( GET_OPTIONAL_STRING_PARAMETER(KVersionName, aSection, name))
		{
		if ( name != version.Name() )
			{
			ERR_PRINTF3(_L("Name does not match expected name: %S, %S"), &name, &versionName);
			SetBlockResult(EFail);
			}
		}

	TInt	intTemp;
	if ( GET_OPTIONAL_INT_PARAMETER(KVersionBuild, aSection, intTemp) )
		{
		if ( intTemp != version.iBuild )
			{
			ERR_PRINTF1(_L("Build does not match expected build"));
			SetBlockResult(EFail);
			}
		}

	if ( GET_OPTIONAL_INT_PARAMETER(KVersionMajor, aSection, intTemp) )
		{
		if ( intTemp != version.iMajor )
			{
			ERR_PRINTF1(_L("Major does not match expected major"));
			SetBlockResult(EFail);
			}
		}

	if ( GET_OPTIONAL_INT_PARAMETER(KVersionMinor, aSection, intTemp) )
		{
		if ( intTemp != version.iMinor )
			{
			ERR_PRINTF1(_L("Minor does not match expected minor"));
			SetBlockResult(EFail);
			}
		}

	if (version.Name() == _L("") && version.iBuild == 0 && version.iMajor == 0 && version.iMinor == 0)
		{
		ERR_PRINTF1(_L("Some version fields are not set!"));
		SetBlockResult(EFail);
		}
	}

void CT_FsData::DoCmdNotifyChangeL(const TDesC& aSection, const TInt aAsyncErrorIndex)
/** Requests a notification of change to files or directories */
	{
	TNotifyType	type = ENotifyAll;
	TPtrC		typeTemp;
	TBool		dataOk = ETrue;

	if ( GET_MANDATORY_STRING_PARAMETER(KType, aSection, typeTemp) )
		{
		if(!ConvertToNotifyType(typeTemp, type))
			{
			TInt	typeNumber;
			if(GetIntFromConfig(aSection, KType(), typeNumber))
				{
				type = (TNotifyType)typeNumber;
				}
			else
				{
				ERR_PRINTF3(_L("NotifyChange() incorrect parameter %S in %S"), &typeTemp, &KType());
				SetBlockResult(EFail);
				dataOk = EFalse;
				}
			}
		}
	else
		{
		dataOk = EFalse;
		}

	TInt	count=1;
	GET_OPTIONAL_INT_PARAMETER(KCount, aSection, count);

	if(dataOk)
		{
		CT_ActiveNotifyChange*	active = CT_ActiveNotifyChange::NewLC(count, aAsyncErrorIndex, *this);
		iNotifyChange.AppendL(active);
		CleanupStack::Pop(active);

		TPtrC	path;
		if ( GetStringFromConfig(aSection, KPath(), path) )
			{
			iFs->NotifyChange(type, active->iStatus, path);
			INFO_PRINTF1(_L("NotifyChange(TNotifyType, TRequestStatus, const TDesC)"));
			}
		else
			{
			iFs->NotifyChange(type, active->iStatus);
			INFO_PRINTF1(_L("NotifyChange(TNotifyType TRequestStatus)"));
			}
			
		active->Activate();
		IncOutstanding();
		}
	}


void CT_FsData::DoCmdNotifyChangeCancel(const TDesC& aSection)
/** Cancels outstanding request(s) for notification of change to files or directories */
	{
	TBool	all = ETrue;

	if ( GET_MANDATORY_BOOL_PARAMETER(KAll, aSection, all) )
		{
		if(all)
			{
			// Cancels all outstanding requests.
			iFs->NotifyChangeCancel();
			INFO_PRINTF1(_L("NotifyChangeCancel()"));
			}
		else
			{
			// Cancels a specific outstanding request
			TInt	index=0;
			GetIntFromConfig(aSection, KIndex(), index);

			iFs->NotifyChangeCancel(iNotifyChange[index]->iStatus);
			INFO_PRINTF1(_L("NotifyChangeCancel(TRequestStatus)"));
			}
		}
	}

void CT_FsData::DoCmdNotifyDiskSpaceL(const TDesC& aSection, const TInt aAsyncErrorIndex)
/** Requests notification when the free disk space on the specified drive crosses the specified threshold value */
	{
	//Get drive number from config
	TDriveNumber	drive = EDriveA;
	TBool 			dataOk = ETrue;
	if (!GetDriveNumberFromConfig(aSection, KDrive, drive))
		{
		ERR_PRINTF2(_L("No %S"), &KDrive());
		SetBlockResult(EFail);
		dataOk = EFalse;
		}

	TBool	useFreeSpace = EFalse;
	GET_OPTIONAL_BOOL_PARAMETER(KUseFreeSpace, aSection, useFreeSpace);

	TInt64 threshold = 0;
	//Defining treshold by free space
	if(useFreeSpace)
		{
		threshold = iVolumeInfo.iFree;
		//For Calculation free-temp(_sub), free+temp(_add)
		TInt temp;
		if(GetIntFromConfig(aSection, KAdd, temp))
			{
			threshold += temp;
			temp = 0;
			}
		if(GetIntFromConfig(aSection, KSub, temp))
			{
			threshold -= temp;
			temp = 0;
			}
		}
	//Defining treshold by some value
	else
		{
		TPtrC thold;
		if(GET_MANDATORY_STRING_PARAMETER(KThreshold, aSection, thold))
			{
			TLex lex(thold);
			TInt err = lex.Val(threshold);
			if(err)
				{
				ERR_PRINTF1(_L("NotifyDiskSpace() bad treshold value"));
				SetBlockResult(EFail);
				dataOk = EFalse;
				}
			}
		}

	if(dataOk)
		{
		CActiveCallback*	active = CActiveCallback::NewLC(*this);
		iNotifyDiskSpace.AppendL(active);
		CleanupStack::Pop(active);

		iFs->NotifyDiskSpace(threshold, drive, active->iStatus);
		INFO_PRINTF1(_L("NotifyDiskSpace()"));
		active->Activate(aAsyncErrorIndex);
		IncOutstanding();
		}
	}


void CT_FsData::DoCmdNotifyDiskSpaceCancel(const TDesC& aSection)
/** Cancels a specific outstanding request for free disk space notification */
	{

	TBool all = ETrue;

	if(GET_MANDATORY_BOOL_PARAMETER(KAll, aSection, all))
		{
		if (all)
			{
			//Cancels all outstanding requests.
			iFs->NotifyDiskSpaceCancel();
			INFO_PRINTF1(_L("NotifyDiskSpaceCancel()"));
			}
		else
			{
			// Cancels a specific outstanding request
			TInt	index=0;
			GetIntFromConfig(aSection, KIndex, index);

			iFs->NotifyDiskSpaceCancel(iNotifyDiskSpace[index]->iStatus);
			}
		}
	}

void CT_FsData::DoCmdIsRomAddress(const TDesC& aSection)
/** Tests whether the specified address is in ROM */
	{
	//reading address
	TUint8* address = NULL;
	TInt intAddress;
	TBool dataOk = ETrue;
	
	if(GetHexFromConfig(aSection, KAddress, intAddress))
		{
		address = (TUint8*)intAddress;
		}
	else if(iIsFileInRom)
		{
		address = iIsFileInRom;
		}
	else
		{
		ERR_PRINTF1(_L("Address not specified"));
		SetBlockResult(EFail);
		dataOk = EFalse;
		}
	if(dataOk)
		{
		INFO_PRINTF2(_L("Address %X"), address);
		//Address of file in ROM
		TBool	actual = RFs::IsRomAddress(address);
		INFO_PRINTF2(_L("RFs::IsRomAddress() %d"), actual);
			//Reading expected result
		TBool	expected = EFalse;
		if ( GET_OPTIONAL_BOOL_PARAMETER(KInRom, aSection, expected) )
			{
			if ( expected != actual )
				{
				ERR_PRINTF1(_L("Expected result does not match actual"));
				SetBlockResult(EFail);
				}
			}
		}
	}

void CT_FsData::DoCmdResourceCountMarkStart()
/** Marks the start of resource count checking */
	{
	iFs->ResourceCountMarkStart();
	INFO_PRINTF1(_L("ResourceCountMarkStart()"));
	}

void CT_FsData::DoCmdResourceCountMarkEnd()
/** Ends resource count checking */
	{
	iFs->ResourceCountMarkEnd();
	INFO_PRINTF1(_L("ResourceCountMarkEnd()"));
	}

void CT_FsData::DoCmdResourceCount(const TDesC& aSection)
/** Gets the number of currently open resources */
	{
	TInt	resources = iFs->ResourceCount();//Number of resources currently opened
	INFO_PRINTF2(_L("ResourceCount() = %d"), resources);

	TInt expectedValue = 0; //Number of resources from config
	if(GetIntFromConfig(aSection, KResources, expectedValue))
		{
		if (expectedValue != resources)
			{
			ERR_PRINTF3(_L("ResourceCount() %d != %d expected value"), resources, expectedValue);
			SetBlockResult(EFail);
			}
		}
	}

void CT_FsData::DoCmdGetNotifyUser(const TDesC& aSection)
/** Tests whether user notification of file read or write failure is in effect */
	{
	TBool	actual = iFs->GetNotifyUser();
	INFO_PRINTF2(_L("iFs->GetNotifyUser() %d"), actual);

	TBool expected = EFalse;
	if ( GET_OPTIONAL_BOOL_PARAMETER(KNotify, aSection, expected) )
		{
		if ( expected!=actual )
			{
			ERR_PRINTF1(_L("Expected result does not match actual"));
			SetBlockResult(EFail);
			}
		}
	}

void CT_FsData::DoCmdSetNotifyUser(const TDesC& aSection)
/** Sets whether the user should be notified of file read or write failure */
	{
	TBool notify = EFalse;

	if(GET_MANDATORY_BOOL_PARAMETER(KNotify, aSection, notify))
		{
		iFs->SetNotifyUser(notify);
		TPtrC val = notify ? _L("TRUE") : _L("FALSE");
		INFO_PRINTF2(_L("SetNotifyUser() %S"), &val);
		}


	}

void CT_FsData::DoCmdLoaderHeapFunctionL(const TDesC& aSection)
/** returns KErrNotSupported*/
	{
	TPtrC	name;
	TAny*	param1 = NULL;
	if(GetStringFromConfig(aSection, KParam1(), name))
		{
			//param1 = iDataDictionary->GetObject(name);
		}

	TAny* param2 = NULL;
	if(GetStringFromConfig(aSection, KParam2(), name))
		{
			//param2 = iDataDictionary->GetObjectL(name);
		}

	TInt	functionId = 0;
	if(GET_MANDATORY_INT_PARAMETER(KFunctionId(), aSection, functionId))
		{
		TInt err = iFs->LoaderHeapFunction(functionId, param1, param2);
		if( err!=KErrNone )
			{
			ERR_PRINTF2(_L("LoaderHeapFunction() ERROR: %d"), err);
			SetError(err);
			}
		}
	}

void CT_FsData::DoCmdSetNotifyChange(const TDesC& aSection)
/** Enables/Disables change notification on a per-session basis. */
	{

	TBool notify = EFalse;

	if(GET_MANDATORY_BOOL_PARAMETER(KNotify, aSection, notify))
		{
		TInt err = iFs->SetNotifyChange(notify);

		TPtrC val = notify ? _L("TRUE") : _L("FALSE");
		if (err == KErrNone)
			{
			INFO_PRINTF2(_L("SetNotifyChange() %S"), &val);
			}
		else
			{
			ERR_PRINTF3(_L("SetNotifyChange() %S, Error: %d"), &val, err);
			SetError(err);
			}
		}
	}

void CT_FsData::DoCmdInitialisePropertiesFile(const TDesC& aSection)
/** Sets the F32 properties file ONLY in ESTART */
	{
	TPtrC tempStr;
	if(GET_MANDATORY_STRING_PARAMETER(KFile, aSection, tempStr))
		{
		TBuf8<KBufferStringLength>	buffer;
		buffer.Copy(tempStr);
		TPtrC8						iniFilePtr(buffer);
		INFO_PRINTF2(_L("InitialisePropertiesFile() %S"), &tempStr);

		TInt	err = iFs ->InitialisePropertiesFile(iniFilePtr);
		if (err != KErrNone)
			{
			ERR_PRINTF2(_L("InitialisePropertiesFile() Error: %d"), err);
			SetError(err);
			}
		}
	}

void CT_FsData::RunL(CActive* aActive, TInt aIndex)
	{
	INFO_PRINTF1(_L("CT_FsData::RunL Called"));
	TBool	foundActiveObject = EFalse;
	TInt	index=0;
	TInt	count=0;
	TBool	completed=ETrue;

	// See if it is in iNotifyChange
	count=iNotifyChange.Count();
	for( index=0; (index<count) && (!foundActiveObject); ++index )
 		{
 		if( aActive == iNotifyChange[index] )
			{
			INFO_PRINTF1(_L("RunL iNotifyChange called"));
			foundActiveObject = ETrue;
			if ( iNotifyChange[index]->DecCount()>0 )
				{
				completed=EFalse;
				iNotifyChange[index]->Activate();
				}
			else
				{
				iNotifyChange.Remove(index);
				}
	 		}
		}

	// See if it is in iNotifyDiskSpace
	count=iNotifyDiskSpace.Count();
	for( index=0; (index<count) && (!foundActiveObject); ++index )
 		{
 		if( aActive == iNotifyDiskSpace[index] )
			{
			INFO_PRINTF1(_L("RunL iNotifyDiskSpace called"));
			foundActiveObject = ETrue;
			iNotifyDiskSpace.Remove(index);
	 		}
		}

	// See if it is in iNotifyDismount
	count=iNotifyDismount.Count();
	for( index=0; (index<count) && (!foundActiveObject); ++index )
 		{
 		if( aActive == iNotifyDismount[index] )
			{
			INFO_PRINTF1(_L("RunL iNotifyDismount called"));
			foundActiveObject = ETrue;
			iNotifyDismount.Remove(index);
	 		}
		}

	// See if it is in iStartupInitComplete
	count=iStartupInitComplete.Count();
	for( index=0; (index<count) && (!foundActiveObject); ++index )
 		{
 		if( aActive == iStartupInitComplete[index] )
			{
			INFO_PRINTF1(_L("RunL iStartupInitComplete called"));
			foundActiveObject = ETrue;
			iStartupInitComplete.Remove(index);
	 		}
		}

 	if( foundActiveObject )
 		{
		TInt	err = aActive->iStatus.Int();
		if( err != KErrNone )
			{
			ERR_PRINTF2(_L("RunL Error %d"), err);
			SetAsyncError( aIndex, err );
			}

		if ( completed )
			{
			// Reset the outstanding request state
			delete aActive;
			DecOutstanding();
			}
		}
	else
		{
 		ERR_PRINTF1(_L("Stray RunL signal"));
 		SetBlockResult(EFail);
		}
	}

void CT_FsData::DoCancel(CActive* aActive, TInt aIndex)
	{
	TBool	foundActiveObject = EFalse;

	TInt	index=0;
	TInt	count=0;

	// See if it is in iNotifyChange
	count=iNotifyChange.Count();
	for( index=0; (index<count) && (!foundActiveObject); ++index )
 		{
 		if( aActive == iNotifyChange[index] )
			{
			INFO_PRINTF1(_L("DoCancel iNotifyChange called"));
			foundActiveObject = ETrue;
			iNotifyChange.Remove(index);
	 		}
		}

	// See if it is in iNotifyDiskSpace
	count=iNotifyDiskSpace.Count();
	for( index=0; (index<count) && (!foundActiveObject); ++index )
 		{
 		if( aActive == iNotifyDiskSpace[index] )
			{
			INFO_PRINTF1(_L("DoCancel iNotifyDiskSpace called"));
			foundActiveObject = ETrue;
			iNotifyDiskSpace.Remove(index);
	 		}
		}

	// See if it is in iNotifyDismount
	count=iNotifyDismount.Count();
	for( index=0; (index<count) && (!foundActiveObject); ++index )
 		{
 		if( aActive == iNotifyDismount[index] )
			{
			INFO_PRINTF1(_L("DoCancel iNotifyDismount called"));
			foundActiveObject = ETrue;
			iNotifyDismount.Remove(index);
	 		}
		}

	// See if it is in iStartupInitComplete
	count=iStartupInitComplete.Count();
	for( index=0; (index<count) && (!foundActiveObject); ++index )
 		{
 		if( aActive == iStartupInitComplete[index] )
			{
			INFO_PRINTF1(_L("DoCancel iStartupInitComplete called"));
			foundActiveObject = ETrue;
			iStartupInitComplete.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);
		}
	}
TBool CT_FsData::ConvertToNotifyType(const TDesC& aNotifyTypeStr, TNotifyType& aNotifyType)
{
	TBool ret = ETrue;
	if(aNotifyTypeStr == _L("ENotifyAll"))
		{
		aNotifyType = ENotifyAll;
		}
	else if(aNotifyTypeStr == _L("ENotifyEntry"))
		{
		aNotifyType = ENotifyEntry;
		}
	else if(aNotifyTypeStr == _L("ENotifyFile"))
		{
		aNotifyType = ENotifyFile;
		}
	else if(aNotifyTypeStr == _L("ENotifyDir"))
		{
		aNotifyType = ENotifyDir;
		}
	else if(aNotifyTypeStr == _L("ENotifyAttributes"))
		{
		aNotifyType = ENotifyAttributes;
		}
	else if(aNotifyTypeStr == _L("ENotifyWrite"))
		{
		aNotifyType = ENotifyWrite;
		}
	else if(aNotifyTypeStr == _L("ENotifyDisk"))
		{
		aNotifyType = ENotifyDisk;
		}
	//For COnverting data ENotifyFile|ENotifyDir
	else
		{
		TInt	location=aNotifyTypeStr.Match(_L("*|*"));
		if( location!=KErrNotFound )
			{
			//Converting Left part of the data
			TPtrC		tempStr=aNotifyTypeStr.Left(location);
			ret=ConvertToNotifyType(tempStr, aNotifyType);

			//Converting right data can be with another "|"
			tempStr.Set(aNotifyTypeStr.Mid(location+1));

			TNotifyType	notifyTypeTmp;
			if ( ConvertToNotifyType(tempStr, notifyTypeTmp) )
				{
				aNotifyType =(TNotifyType)((TInt)aNotifyType|(TInt)notifyTypeTmp);
				}
			else
				{
				ret = EFalse;
				}
			}
		else
			{
			ret = EFalse;
			}
		}

	return ret;
	}