/*

* All rights reserved.

* This component and the accompanying materials are made available

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

*

*

*/

/**

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