/*

 * 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;

 	}