/*

* 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

v

This contains CT_DirScanData

*/

//	User includes

#include "T_DirScanData.h"

#include "T_SfSrvServer.h"

/*@{*/

///	Parameters

_LIT(KAttMask,							"attmask" );

_LIT(KRfsObject,						"rfsObject");

_LIT(KDirObject,						"dirObject");

_LIT(KExpected,							"expected");

_LIT(KPath,								"path");

_LIT(KEntrySortKey,						"sortkey");

_LIT(KScanDirection,					"scandirection");

///Commands

_LIT(KCmdNewL,							"NewL");

_LIT(KCmdNewLC,							"NewLC");

_LIT(KCmdSetScanDataL,					"SetScanDataL");

_LIT(KCmdFullPath,						"FullPath");

_LIT(KCmdAbbreviatedPath,				"AbbreviatedPath");

_LIT(KCmdNextL,							"NextL");

_LIT(KCmdDestructor,					"~");

//	Sort key

_LIT(KESortNone,						"ESortNone");

_LIT(KESortByName,						"ESortByName");

_LIT(KESortByExt,						"ESortByExt");

_LIT(KESortBySize,						"ESortBySize");

_LIT(KESortByDate,						"ESortByDate");

_LIT(KESortByUid,						"ESortByUid");

_LIT(KEDirsAnyOrder,					"EDirsAnyOrder");

_LIT(KEDirsFirst,						"EDirsFirst");

_LIT(KEDirsLast,						"EDirsLast");

_LIT(KEAscending,						"EAscending");

_LIT(KEDescending,						"EDescending");

_LIT(KEDirDescending,					"EDirDescending");

// Scan directions

_LIT(KEScanUpTree,	 					"EScanUpTree");

_LIT(KEScanDownTree,	 				"EScanDownTree");

CT_DirScanData* CT_DirScanData::NewL()

/**

* Two phase constructor

*/

	{

	CT_DirScanData* ret = new (ELeave) CT_DirScanData();

	CleanupStack::PushL(ret);

	ret->ConstructL();

	CleanupStack::Pop(ret);

	return ret;

	}

CT_DirScanData::CT_DirScanData()

:	iDirScan(NULL)

/**

* Protected constructor. First phase construction

*/

	{

	}

void CT_DirScanData::ConstructL()

/**

* Protected constructor. Second phase construction

*/

	{

	}

CT_DirScanData::~CT_DirScanData()

/**

* Destructor.

*/

	{

	DoCleanup();

	}

TAny* CT_DirScanData::GetObject()

	{

	return iDirScan;

	}

TBool	CT_DirScanData::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 == KCmdNewLC)

		{

		DoCmdNewLC(aSection);

		}

	else if (aCommand == KCmdSetScanDataL)

		{

		DoCmdSetScanDataL(aSection);

		}

	else if (aCommand == KCmdNextL)

		{

		DoCmdNextL(aSection);

		}

	else if (aCommand == KCmdAbbreviatedPath)

		{

		DoCmdAbbreviatedPath(aSection);

		}

	else if (aCommand == KCmdFullPath)

		{

		DoCmdFullPath(aSection);

		}

	else

		{

		retVal = EFalse;

		}

	return retVal;

	}

void CT_DirScanData::DoCleanup()

	{

	INFO_PRINTF1(_L("Doing cleanup!"));

	if (iDirScan)

		{

		delete iDirScan;

		iDirScan = NULL;

		}

	}

void CT_DirScanData::DoCmdNewL(const TDesC& aSection)

	{

	INFO_PRINTF1(_L("Constructing CDirScan object!"));

	RFs*	rfsObject = NULL;

	TPtrC	rfsObjectName;

	if (GET_MANDATORY_STRING_PARAMETER(KRfsObject, aSection, rfsObjectName))

		{

		rfsObject = (RFs*)GetDataObjectL(rfsObjectName);

		}

	DoCleanup();

	TRAPD (error, iDirScan = CDirScan::NewL(*rfsObject));

	if (error == KErrNone)

		{

		INFO_PRINTF1(_L("CDirScan object has been created with NewL constructor!"));			

		}

	else

		{

		ERR_PRINTF2(_L("CDirScan object is not created with NewL constructor! Error code: %d"), error);

		SetError(error);

		}

	}

void CT_DirScanData::DoCmdNewLC(const TDesC& aSection)

	{

	INFO_PRINTF1(_L("Constructing CDirScan object!"));

	RFs*	rfsObject = NULL;

	TPtrC	rfsObjectName;

	if (GET_MANDATORY_STRING_PARAMETER(KRfsObject, aSection, rfsObjectName))

		{

		rfsObject = (RFs*)GetDataObjectL(rfsObjectName);

		}

	DoCleanup();

	TRAPD (error, iDirScan = CDirScan::NewLC(*rfsObject); CleanupStack::Pop(iDirScan) );

	if (error == KErrNone)

		{

		INFO_PRINTF1(_L("CDirScan object has been created with NewLC constructor!"));

		}

	else

		{

		ERR_PRINTF2(_L("CDirScan object is not created with NewLC constructor! Error code: %d"), error);

		SetError(error);

		}

	}

void CT_DirScanData::DoCmdSetScanDataL(const TDesC& aSection)

	{

	INFO_PRINTF1(_L("Setting data scanning!"));

	TBool	dataOk = ETrue;

	TPtrC	path;

	if (!GET_MANDATORY_STRING_PARAMETER(KPath(), aSection, path))

		{

		dataOk = EFalse;

		}

	TUint	attMask = KEntryAttHidden;

	if ( !FileserverUtil::GetAttMask(*this, aSection, KAttMask(), attMask))

        {

       	dataOk = EFalse;

       	}

	TPtrC	entrySortKey;

	TUint	sortKey = ESortNone;

	if (GET_OPTIONAL_STRING_PARAMETER(KEntrySortKey(), aSection, entrySortKey))

		{

		if ( !ConvertToSortKey(entrySortKey, sortKey) )

			{

			TInt	intTemp;

			if ( GET_MANDATORY_INT_PARAMETER(KEntrySortKey(), aSection, intTemp) )

				{

				sortKey=intTemp;

				}

			else

				{

				dataOk = EFalse;

				}

			}

		}

	TPtrC						entryScanDirection;

	CDirScan::TScanDirection	scanDirection = CDirScan::EScanDownTree;

	if (GET_OPTIONAL_STRING_PARAMETER(KScanDirection(), aSection, entryScanDirection))

		{

		if ( !ConvertToScanDirection(entryScanDirection, scanDirection))

            {

           	dataOk = EFalse;

           	}

		}

	if (dataOk)

		{

		TRAPD (err, iDirScan->SetScanDataL(path, attMask, sortKey, scanDirection));

		if(err == KErrNone)

			{

			INFO_PRINTF1(_L("SetScanDataL complete!"));

			}

		else

			{

			ERR_PRINTF2(_L("SetScanDataL() Error: %d"), err);

			SetError(err);

			}

		}

	}	

void CT_DirScanData::DoCmdNextL(const TDesC& aSection)

	{

	INFO_PRINTF1(_L("Scanning next directory entries!"));

	CDir*		dirObject = NULL;

	CT_DirData* dirWrapperObject = NULL;

	TPtrC		dirObjectName;

	if (GET_MANDATORY_STRING_PARAMETER(KDirObject, aSection, dirObjectName))

		{

		dirWrapperObject = static_cast<CT_DirData*>(GetDataWrapperL(dirObjectName));

		}

	TRAPD (err, iDirScan->NextL(dirObject));

	if (err == KErrNone)

		{

		if (dirObject == NULL)

			{

			INFO_PRINTF1(_L("CDir instance is NULL, there is no directory left to go."));

			}

		else

			{

			INFO_PRINTF1(_L("Scanning the next directory entry completed successfully!"));

			}

		}

	else

		{

		ERR_PRINTF2(_L("Can't scan the next directory entry in the structure Error code: %d"), err);

		SetError(err);

		}

	if (dirObject)

		{

		if(dirWrapperObject)

			{

			dirWrapperObject->SetObjectL(dirObject);

			}

		else

		    {

		    delete dirObject;

		    dirObject = NULL;			        

		    }

		}	

	}

void CT_DirScanData::DoCmdAbbreviatedPath(const TDesC& aSection)

	{

	INFO_PRINTF1(_L("Getting directory abbreviated path!"));

	TPtrC	expected;

	if (GET_MANDATORY_STRING_PARAMETER(KExpected(), aSection, expected))

		{

		TPtrC	abbPath;

		abbPath.Set(iDirScan->AbbreviatedPath());

		if (abbPath != expected)

			{

			ERR_PRINTF3(_L("Result (%S) didn't match with expected result (%S)!"), &abbPath, &expected);

			SetBlockResult(EFail);

			}

		else 

			{

			INFO_PRINTF2(_L("Result (%S) match with expected result!"), &abbPath);

			}

		}

	}

void CT_DirScanData::DoCmdFullPath(const TDesC& aSection)

	{

	INFO_PRINTF1(_L("Getting directory full path!"));

	TPtrC	expected;

	if (GET_MANDATORY_STRING_PARAMETER(KExpected(), aSection, expected))

		{

		TPtrC	fullPath;

		fullPath.Set(iDirScan->FullPath());

		if (fullPath != expected)

			{

			ERR_PRINTF3(_L("Result (%S) didn't match with expected result (%S)!"), &fullPath, &expected);

			SetBlockResult(EFail);

			}

		else 

			{

			INFO_PRINTF2(_L("Result (%S) match with expected result!"), &fullPath);

			}

		}

	}

TBool CT_DirScanData::ConvertToSortKey(const TDesC& aSortKeyStr, TUint& aSortKey)

	{

	TBool ret = ETrue;

	if (aSortKeyStr == KESortNone)

		{

		aSortKey = ESortNone;

		}

	else if (aSortKeyStr == KESortByName)

		{

		aSortKey = ESortByName;

		}

	else if (aSortKeyStr == KESortByExt)

		{

		aSortKey = ESortByExt;

		}

	else if (aSortKeyStr == KESortBySize)

		{

		aSortKey = ESortBySize;

		}

	else if (aSortKeyStr == KESortByDate)

		{

		aSortKey = ESortByDate;

		}

	else if (aSortKeyStr == KESortByUid)

		{

		aSortKey = ESortByUid;

		}

	else if (aSortKeyStr == KEDirsAnyOrder)

		{

		aSortKey = EDirsAnyOrder;

		}

	else if (aSortKeyStr == KEDirsFirst)

		{

		aSortKey = EDirsFirst;

		}

	else if (aSortKeyStr == KEDirsLast)

		{

		aSortKey = EDirsLast;

		}

	else if (aSortKeyStr == KEAscending)

		{

		aSortKey = EAscending;

		}

	else if (aSortKeyStr == KEDescending)

		{

		aSortKey = EDescending;

		}

	else if (aSortKeyStr == KEDirDescending)

		{

		aSortKey = EDirDescending;

		}

	else if (aSortKeyStr.Match((_L("*|*"))) != KErrNotFound)

		{

		TUint tmpSortKey;

		TInt location = aSortKeyStr.Match(_L("*|*"));

		//Converting Left part of the data

		TPtrC left = aSortKeyStr.Left(location);

		if (ConvertToSortKey(left, tmpSortKey))

			{

			aSortKey = tmpSortKey;

			}

		else

			{

			ret = EFalse;

			}

		//Converting right data can be with another "|"

		TPtrC right = aSortKeyStr.Mid(location + 1);

		if (ConvertToSortKey(right, tmpSortKey))

			{

			aSortKey = aSortKey | tmpSortKey;

			}

		else

			{

			ret = EFalse;

			}

		}

	else

		{

		ret = EFalse;

		}

	return ret;

	}

TBool CT_DirScanData::ConvertToScanDirection(const TDesC& aScanDirectionStr, CDirScan::TScanDirection& aScanDirection)

	{

	TBool ret = ETrue;

	if (aScanDirectionStr == KEScanUpTree)

		{

		aScanDirection = CDirScan::EScanUpTree;

		}

	else if (aScanDirectionStr == KEScanDownTree)

		{

		aScanDirection = CDirScan::EScanDownTree;

		}

	else

		{

		ret = EFalse;

		}

	return ret;

	}