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

//

/**

 @file

 @internalTechnology 

*/

// System Include

#include <escapeutils.h>

// User Includes

#include "TestFileUriServer.h"

#include "TestCreateFileStep.h"

#include "TestGetFileNameFromUriStep.h"

#include "TestGenerateFileUriStep.h"

#include "TestDeleteFileStep.h"

#include "TestForAllFilesStep.h"

// The system-wide unique name for the test-server

_LIT(KServerName, "TestFileUriServer");

TBuf<KMaxDrives> CTestFileUriServer::iRemovableDrives(KNullDesC);

/**

Static factory constructor. Creates and returns instance of the test server

@return		A pointer to the newly created CTestFileUriServer object

*/

CTestFileUriServer*  CTestFileUriServer::NewL()

	{

	// Construct the server

	CTestFileUriServer* server = new(ELeave) CTestFileUriServer();

	CleanupStack::PushL(server);

	// CServer base class call

	// Name the server using the system-wide unique string

	// Clients use this to create server sessions.

	server->StartL(KServerName);

	CleanupStack::Pop(server);

	return server;

	}

#if (!defined EKA2)

/**

Creates the Active Scheduler, then creates the test-server, synchronises the 

thread with the client and then enters the active scheduler.

This is EKA1 version of MainL(). Uses sempahore to sync with client

as Rendezvous calls are not available

*/

LOCAL_C void MainL()

	{

	// Create and install the active scheduler.

	CActiveScheduler* sched = NULL;

	sched = new(ELeave) CActiveScheduler;

	CleanupStack::PushL(sched);

	CActiveScheduler::Install(sched);

	// Create the server inside trap harness

	CTestFileUriServer *server = NULL;

	TRAPD(err, server = CTestFileUriServer::NewL());

	if (!err)

		{

		CleanupStack::PushL(server);

		RSemaphore sem;

		// The client API of TestExecute will already have created the 

		// semaphore and will be waiting on it.

		User::LeaveIfError(sem.OpenGlobal(KServerName));

		CleanupStack::Pop(server);

		// Signal the client

		sem.Signal();

		sem.Close();

		// Enter the active scheduler

		sched->Start();

		}

	CleanupStack::Pop(sched);

	delete server;

	delete sched;

	}

#else

/**

EKA2 version of MainL()

Uses the new Rendezvous call isntead of the older semaphore.

*/

LOCAL_C void MainL()

	{

	// For platform security

#if (defined __DATA_CAGING__)

	RProcess().DataCaging(RProcess::EDataCagingOn);	

	RProcess().SecureApi(RProcess::ESecureApiOn);	

#endif

	CActiveScheduler* sched = NULL;

	sched = new(ELeave) CActiveScheduler; 

	CActiveScheduler::Install(sched);

	CTestFileUriServer* server = NULL;

	// Create the test-server

	TRAPD(err, server = CTestFileUriServer::NewL());

	if(!err)

		{

		// Sync with the client and enter the active scheduler

		RProcess::Rendezvous(KErrNone);

		sched->Start();

		}

	delete server;

	delete sched;	

	}

#endif		// #if (!defined EKA2)

#if (defined __WINS__ && !defined EKA2)

/**

DLL entry-point for EKA1 emulator builds.

*/

GLDEF_C TInt E32Dll(enum TDllReason /*aDllReason*/)

	{

	return KErrNone;

	}

#else

/**

Exe entry point code, for EKA1 hardware and EKA2 builds.

*/

GLDEF_C TInt E32Main()

	{

	__UHEAP_MARK;

	CTrapCleanup *cleanup = CTrapCleanup::New();

	if (cleanup == NULL)

		{

		return KErrNoMemory;

		}

	TInt err = KErrNone;

	TRAP(err, MainL());

	delete cleanup;

	__UHEAP_MARKEND;

	return KErrNone;

	}

#endif		// #if (defined __WINS__ && !defined EKA2)

#if (defined __WINS__ && !defined EKA2)

/**

For EKA1 emulator builds. This function is called when the thread is first 

resumed. Has the standard thread entry siganture. 

*/

TInt ThreadFunc (TAny* /*aParam*/)

	{

	__UHEAP_MARK;

	CTrapCleanup* cleanup = CTrapCleanup::New();

	if (cleanup == NULL)

		{

		return KErrNoMemory;

		}

	TInt err = KErrNone;

	TRAP(err, MainL());

	delete cleanup;

	__UHEAP_MARKEND;

	return KErrNone;

	}

/**

For EKA1 emulator builds. Creates and starts a thread for the server to run.

*/

EXPORT_C TInt NewServer()

	{

	_LIT(KThread, "Thread");

	RThread thread;

	// Name the thread as "<Server-Name>Thread" making it hopefully unique

	TBuf<KMaxTestExecuteNameLength> threadName(KServerName);

	threadName.Append(KThread);

	const TInt KMaxHeapSize = 0x1000000;

	// Create the thread

	TInt err = thread.Create(threadName, ThreadFunc, KDefaultStackSize, 

							 KMinHeapSize, KMaxHeapSize, NULL, EOwnerProcess);

	if (err != KErrNone)

		{

		return err;

		}

	// Start the thread -> effectively calls ThreadFunc

	thread.Resume();

	thread.Close();

	return KErrNone;

	}

#endif 		// #if (defined __WINS__ && !defined EKA2)

/**

Base class pure virtual

@return - Instance of the test step

*/

CTestStep* CTestFileUriServer::CreateTestStep(const TDesC& aStepName)

	{

	CTestStep *testStep = NULL;

	if (aStepName == KTestCreateFileStep)

		{

		testStep = new (ELeave) CTestCreateFileStep;

		}

	else if (aStepName == KTestGetFileNameFromUriStep)

		{

		testStep = new (ELeave) CTestGetFileNameFromUriStep;

		}	

	else if (aStepName == KTestGenerateFileUriStep)

		{

		testStep = new (ELeave) CTestGenerateFileUriStep;

		}

	else if (aStepName == KTestDeleteFileStep)

		{

		testStep = new (ELeave) CTestDeleteFileStep;

		}

	else if (aStepName == KTestForAllFilesStep)

		{

		testStep = new (ELeave) CTestForAllFilesStep();

		}

		return testStep;

	}

/**

Returns the equivalent drive number of a drive

*/

void CTestFileUriServer::GetDriveNumber(const TDesC& aDrive, TDriveNumber& aDriveNum)

	{

	TBuf<1> driveLetter(aDrive.Left(1));

	driveLetter.LowerCase();

	aDriveNum = static_cast <TDriveNumber> (driveLetter[0] - KLetterA);

	}

/**

Checks whether a specific drive is a removable drive

*/

TInt CTestFileUriServer::IsRemovableDrive(const TDriveNumber& aDriveNum, TBool& aResult)

	{

	TInt err = KErrNone;

	TDriveInfo driveInfo;	

	RFs fs;

	aResult = EFalse;

	err = fs.Connect();

	if(err == KErrNone)

		{

		err = fs.Drive(driveInfo, aDriveNum);

		if (err == KErrNone && driveInfo.iDriveAtt & KDriveAttRemovable)

			{

			aResult = ETrue;

			}

		fs.Close();	

		}

	return err;	

	}

/**

Replaces the drive placeholder <drive> with the actual drive

*/

HBufC16* CTestFileUriServer::CheckAndFillDriveNameL(const TPtrC& aFileUri, const TPtrC& aDrive)

	{

	HBufC16* expectedUriWithDrive = aFileUri.AllocL();

	TInt placeHolderPos = aFileUri.Find(KDrivePlaceHolder);	

	if(placeHolderPos >= KErrNone)

		{

		if(aDrive == KExtMedia)

			{// Create a descriptor that is big enough

			// Just in case ReAllocL leaves

			CleanupStack::PushL(expectedUriWithDrive);

			expectedUriWithDrive = expectedUriWithDrive->ReAllocL(aFileUri.Length() + (KExtMedia().Length() - KDrivePlaceHolder().Length()));

			CleanupStack::Pop(); // expectedUriWithDrive

			}

		expectedUriWithDrive->Des().Replace(placeHolderPos, KDrivePlaceHolder().Length(), aDrive);

		}

	return expectedUriWithDrive;

	}

/**

Private function used to find the remobale drives and populate iRemovableDrives

*/

TInt CTestFileUriServer::PopulateRemovableDrivesBuf(const RFs& aFs)

	{

	TInt err = KErrNone;

	TDriveInfo driveInfo;

	TInt driveNum;

	for (driveNum = EDriveA; driveNum <= EDriveZ; driveNum++)   

		{

		// Populate iRemovableDrives with all removable drives in alphabetical order

		err = aFs.Drive(driveInfo, driveNum);

		if (err == KErrNone && (driveInfo.iDriveAtt & KDriveAttRemovable))       

			{

			iRemovableDrives.Append(TInt16('a' + driveNum));

			}

		}

	return err;

	}

/**

Searches whether a file with same name and path exists in any other removable drive

*/

TInt CTestFileUriServer::FirstRemovableDriveWithSameFileName(const TDesC& aFileName, TBuf<1>& aCorrectDrive)

	{

	aCorrectDrive = aFileName.Left(1);

	TInt err = KErrNone;

	RFs fs;

	if((err = fs.Connect()) != KErrNone)

		{

		return err;

		}

	if(iRemovableDrives == KNullDesC)

		{

		if((err = PopulateRemovableDrivesBuf(fs)) != KErrNone)

			{

			return err;

			}

		}

	TInt index;

	HBufC* tempFileName	= NULL;

	if((tempFileName = aFileName.Alloc()) == NULL)

		{

		return KErrGeneral;

		}

	for(index = 0; index < iRemovableDrives.Length(); ++index)

		{

		TUint attValue;

		// change the drive in the filename and check whether such a file exists

		tempFileName->Des()[0] = iRemovableDrives[index];

		err = fs.Att(tempFileName->Des(), attValue);

		if(err == KErrNone)

			{

			aCorrectDrive[0] = iRemovableDrives[index];

			break;

			}

		}

	if(index >= iRemovableDrives.Length())

		{// File not found on any removable drive

		aCorrectDrive = KNullDesC;

		}

	delete tempFileName;

	fs.Close();	

	return KErrNone;

	}

/**

Obtains the private directory of the application and appends it along with the

relative filename and drive to create the fully qualified filename

*/

TInt CTestFileUriServer::CreateFullyQualifiedName(const TPtrC& aRelativeName, const TPtrC& aDrive, TFileName& aFullyQualifiedName)

	{

	RFs fs;

	TInt err = fs.Connect();

	if(err != KErrNone)

		{

		return err;

		}

	// Get private dir name

	err = fs.PrivatePath(aFullyQualifiedName);

	fs.Close();

	if(err != KErrNone)

		{

		return err;

		}

	// Construct fully-qualified filename

	aFullyQualifiedName.Insert(0, KDriveSeparator);

	aFullyQualifiedName.Insert(0, aDrive);

	TInt position = 0;

	// If backslash already exists dont include again

	if(aRelativeName.Left(1) == KBackSlash)

		{

		++position;

		}

	aFullyQualifiedName.Append(aRelativeName.Right(aRelativeName.Length() - position));

	return KErrNone;

	}