/*

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

 */

 //	User includes

 #include "T_RawDiskData.h"

 /*@{*/

 ///	Parameters

 _LIT(KDrive,	        						"drive");

 _LIT(KObjectName,                               "object_name");

 _LIT(KData,										"data");

 _LIT(KPosition,									"position");

 ///Commands

 _LIT(KCmdOpen,                                  "Open");

 _LIT(KCmdClose,                                 "Close");

 _LIT(KCmdNew,                                   "new" );

 _LIT(KCmdDestructor,                            "~" );

 _LIT(KCmdRead,                                  "Read");

 _LIT(KCmdWrite,                                 "Write");

 _LIT(KDriveA,							        "EDriveA");

 _LIT(KDriveB,				        			"EDriveB");

 _LIT(KDriveC,	        						"EDriveC");

 _LIT(KDriveD,						        	"EDriveD");

 _LIT(KDriveE,		        					"EDriveE");

 _LIT(KDriveF,		        					"EDriveF");

 _LIT(KDriveG,				        			"EDriveG");

 _LIT(KDriveH,		        					"EDriveH");

 _LIT(KDriveI,		        					"EDriveI");

 _LIT(KDriveJ,       							"EDriveJ");

 _LIT(KDriveK,							        "EDriveK");

 _LIT(KDriveL,					        		"EDriveL");

 _LIT(KDriveM,				    	    		"EDriveM");

 _LIT(KDriveN,		        					"EDriveN");

 _LIT(KDriveO,       							"EDriveO");

 _LIT(KDriveP,					    	    	"EDriveP");

 _LIT(KDriveQ,					        		"EDriveQ");

 _LIT(KDriveR,		        					"EDriveR");

 _LIT(KDriveS,	    		    				"EDriveS");

 _LIT(KDriveT,   				    			"EDriveT");

 _LIT(KDriveU,							        "EDriveU");

 _LIT(KDriveV,					        		"EDriveV");

 _LIT(KDriveW,				        			"EDriveW");

 _LIT(KDriveX,				           			"EDriveX");

 _LIT(KDriveY,				    	    		"EDriveY");

 _LIT(KDriveZ,			    	    			"EDriveZ");

 /*@}*/

 CT_RawDiskData* CT_RawDiskData::NewL()

 /**

 * Two phase constructor

 */

 	{

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

 	CleanupStack::PushL(ret);

 	ret->ConstructL();

 	CleanupStack::Pop(ret);

 	return ret;

 	}

 CT_RawDiskData::CT_RawDiskData()

 :	iRawDisk(NULL)

 /**

 * Protected constructor. First phase construction

 */

 	{

 	}

 void CT_RawDiskData::ConstructL()

 /**

 * Protected constructor. Second phase construction

 */

 	{

 	}

 CT_RawDiskData::~CT_RawDiskData()

 /**

 * Destructor.

 */

 	{

 	DoCleanup();

 	}

 void CT_RawDiskData::DoCleanup()

 /**

 * Contains cleanup implementation

 */

 	{

 	//Deleting RRawDisk.

 	if (iRawDisk)

 		{

 		DoCmdClose();

 		INFO_PRINTF1(_L("Deleting current RRawDisk"));

 		delete iRawDisk;

 		iRawDisk = NULL;

 		}

 	}

 TAny* CT_RawDiskData::GetObject()

 /**

 * Return a pointer to the object that the data wraps

 *

 * @return pointer to the object that the data wraps

 */

 	{

 	return iRawDisk;

 	}

 TBool CT_RawDiskData::DoCommandL(const TTEFFunction& aCommand, const TTEFSectionName& aSection, const TInt /*aAsyncErrorIndex*/)

 /**

  * Process a command read from the ini file

  *

  * @param	aCommand requiring command to be processed

  * @param	aSection the section in the ini file requiring the command to be processed

  * @param	aAsyncErrorIndex the index of asynchronous command error code belongs to.

  *

  * @leave	system wide error

  *

  * @return	ETrue if the command is processed

  */

 	{

 	TBool retVal = ETrue;

 	if (aCommand == KCmdNew)

 		{

 		DoCmdNewL();

 		}

 	else if (aCommand == KCmdDestructor)

 		{

 		DoCmdDestructor();

 		}

     else if (aCommand == KCmdOpen)

 	    {

 	    DoCmdOpen(aSection);

 	    }

 	else if (aCommand == KCmdClose)

 	    {

 	    DoCmdClose();

 	    }

     else if (aCommand == KCmdRead)

         {

         DoCmdReadL(aSection);

         }

     else if (aCommand == KCmdWrite)

         {

         DoCmdWriteL(aSection);

         }

 	else

 		{

 		retVal = EFalse;

 		}

 	return retVal;

 	}

 void CT_RawDiskData::DoCmdNewL()

 /** Creates new RRawDisk class instance */

 	{

 	//Deletes previous RRawDisk class instance if it was already created.

 	DoCleanup();

 	INFO_PRINTF1(_L("Create new RRawDisk class instance"));

 	// do create

 	TRAPD(err, iRawDisk = new (ELeave) RRawDisk());

 	if (err != KErrNone)

 		{

 		ERR_PRINTF2(_L("new error %d"), err);

 		SetError(err);

 		}

 	else

 		{

 		INFO_PRINTF1(_L("Create new RRawDisk class instance completed successfully!"));

 		}

 	}

 void CT_RawDiskData::DoCmdDestructor()

 /** Destroy RRawDisk the object */

 	{

 	DoCleanup();

 	}

 void CT_RawDiskData::DoCmdOpen(const TDesC& aSection)

 /** RRawDisk::Open */

 	{

 	INFO_PRINTF1(_L("Opening a direct access channel to the disk!"));

 	RFs* rfsObject = NULL;

 	TPtrC rfsObjectName;

 	if (GET_MANDATORY_STRING_PARAMETER(KObjectName, aSection, rfsObjectName))

 		{

 		TRAPD(err, rfsObject = (RFs*)GetDataObjectL(rfsObjectName));

 		if (err == KErrNone)

 			{

     		// get drive number from parameters

     		TDriveNumber driveNumber = EDriveA;

     		if (!GetDriveNumber(aSection, KDrive(), driveNumber))

     			{

     			ERR_PRINTF2(_L("No %S"), &KDrive());

     			SetBlockResult(EFail);

     			}

     		else

     		    {

 		   		TInt err = KErrNone;

             	err = iRawDisk->Open(*rfsObject, driveNumber);

 	    		if (err != KErrNone)

 	    			{

 	    			ERR_PRINTF2(_L("Opening iRawDisk failed with error : %d"), err);

 	    			SetError( err );

 	    			}

 	    		else

 					{

 					INFO_PRINTF1(_L("Opening iRawDisk completed successfully!"));

 					}

 	    	    }

 			}

 		else

 			{

 			ERR_PRINTF1(_L("Error with fileserver"));

     		SetBlockResult(EFail);	

 			}

 		}

 	}

 void CT_RawDiskData::DoCmdClose()

 /** RRawDisk::Close */

 	{

 	INFO_PRINTF1(_L("Closing current RRawDisk"));

 	iRawDisk->Close();

 	}

 void CT_RawDiskData::DoCmdReadL( const TDesC& aSection )

     {

 	INFO_PRINTF1(_L("Reading directly from disc!"));

     TInt err = KErrNone;

     TPtrC	expectedData;

 	if(GET_MANDATORY_STRING_PARAMETER(KData(), aSection, expectedData))

 		{		

 		HBufC* expectedResultBuf = HBufC::NewL(expectedData.Length());

 		TPtr expectedResult = expectedResultBuf->Des();

 		expectedResult.Copy(expectedData);

 		INFO_PRINTF2(_L("Expecting data: %S"), &expectedResult);

 		HBufC8* readBuf = HBufC8::NewL( expectedData.Length());

 		TPtr8 readBufPtr = readBuf->Des();

 		TInt64 pos = 0;

 		GET_OPTIONAL_INT64_PARAMETER(KPosition(), aSection, pos);

 		err = iRawDisk->Read(pos, readBufPtr);

 		if(err == KErrNone)

 			{

 			HBufC* readResultBuf = HBufC::NewL(readBufPtr.Length());

 			TPtr readResult = readResultBuf->Des();

 			readResult.Copy(readBufPtr);

 			INFO_PRINTF2(_L("Reading data: %S"), &readResult);

 			if (readResult != expectedResult)

 				{

 				ERR_PRINTF3(_L("Read data does not match expected data! Read: %S expected: %S"), &readResult, &expectedResult);

 				SetBlockResult( EFail );	

 				}

 			else

 				{

 				INFO_PRINTF1(_L("Reading data directly from disc was successful!"));	

 				}

 			delete readResultBuf;

 			readResultBuf = NULL;

 			}

 		else

 			{

 			ERR_PRINTF2(_L("Reading data directly from disc failed with error %d"), err);

 			SetError(err);

 			}

 		delete expectedResultBuf;

 		expectedResultBuf = NULL;

 		delete readBuf;

 		readBuf = NULL;

 		}

     else

     	{

     	ERR_PRINTF2(_L("No %S"), &KData());

     	SetBlockResult(EFail);

     	}

     }

 void CT_RawDiskData::DoCmdWriteL( const TDesC& aSection )

     {

     INFO_PRINTF1(_L("Writing directly to disc!"));

     TPtrC	writeData;

 	if(GET_MANDATORY_STRING_PARAMETER(KData(), aSection, writeData))

 		{

 		INFO_PRINTF2(_L("Writing following data: %S"), &writeData);

 		HBufC8*	writeBuf = NULL;

 		TRAPD (err, writeBuf = HBufC8::NewL( writeData.Length() ));

 		if (err == KErrNone)

 			{

 			TPtr8 writeBufPtr = writeBuf->Des();

 			writeBufPtr.Copy(writeData);

 			TInt64 pos = 0;

 			GET_OPTIONAL_INT64_PARAMETER(KPosition(), aSection, pos);

 			err = iRawDisk->Write(pos, writeBufPtr);

 			if(err == KErrNone)

 				{

 				INFO_PRINTF1(_L("Writing data directly to disc was successful!"));

 				}

 			else

 				{

 				ERR_PRINTF2(_L("Writing data directly to disc failed with error %d"), err);

 				SetError(err);

 				}

 			delete writeBuf;

 			writeBuf = NULL;

 			}

 		}

     else

     	{

     	ERR_PRINTF2(_L("No %S"), &KData());

     	SetBlockResult(EFail);

     	}

     }

 TBool CT_RawDiskData::GetDriveNumber(const TDesC& aSection, const TDesC& aParameterName, TDriveNumber& aDriveNumber)

 /** Reads drive number from INI-file */

     {

 	// Read drive number from INI file

 	TPtrC driveNumberStr;

 	TBool ret = GET_OPTIONAL_STRING_PARAMETER(aParameterName, aSection, driveNumberStr);

 	if (ret)

 		{

 		if (driveNumberStr == KDriveA)

 			{

 			aDriveNumber = EDriveA;

 			}

 		else if (driveNumberStr == KDriveB)

 			{

 			aDriveNumber = EDriveB;

 			}

 		else if (driveNumberStr == KDriveC)

 			{

 			aDriveNumber = EDriveC;

 			}

 		else if (driveNumberStr == KDriveD)

 			{

 			aDriveNumber = EDriveD;

 			}

 		else if (driveNumberStr == KDriveE)

 			{

 			aDriveNumber = EDriveE;

 			}

 		else if (driveNumberStr == KDriveF)

 			{

 			aDriveNumber = EDriveF;

 			}

 		else if (driveNumberStr == KDriveG)

 			{

 			aDriveNumber = EDriveG;

 			}

 		else if (driveNumberStr == KDriveH)

 			{

 			aDriveNumber = EDriveH;

 			}

 		else if (driveNumberStr == KDriveI)

 			{

 			aDriveNumber = EDriveI;

 			}

 		else if (driveNumberStr == KDriveJ)

 			{

 			aDriveNumber = EDriveJ;

 			}

 		else if (driveNumberStr == KDriveK)

 			{

 			aDriveNumber = EDriveK;

 			}

 		else if (driveNumberStr == KDriveL)

 			{

 			aDriveNumber = EDriveL;

 			}

 		else if (driveNumberStr == KDriveM)

 			{

 			aDriveNumber = EDriveM;

 			}

 		else if (driveNumberStr == KDriveN)

 			{

 			aDriveNumber = EDriveN;

 			}

 		else if (driveNumberStr == KDriveO)

 			{

 			aDriveNumber = EDriveO;

 			}

 		else if (driveNumberStr == KDriveP)

 			{

 			aDriveNumber = EDriveP;

 			}

 		else if (driveNumberStr == KDriveQ)

 			{

 			aDriveNumber = EDriveQ;

 			}

 		else if (driveNumberStr == KDriveR)

 			{

 			aDriveNumber = EDriveR;

 			}

 		else if (driveNumberStr == KDriveS)

 			{

 			aDriveNumber = EDriveS;

 			}

 		else if (driveNumberStr == KDriveT)

 			{

 			aDriveNumber = EDriveT;

 			}

 		else if (driveNumberStr == KDriveU)

 			{

 			aDriveNumber = EDriveU;

 			}

 		else if (driveNumberStr == KDriveV)

 			{

 			aDriveNumber = EDriveV;

 			}

 		else if (driveNumberStr == KDriveW)

 			{

 			aDriveNumber = EDriveW;

 			}

 		else if (driveNumberStr == KDriveX)

 			{

 			aDriveNumber = EDriveX;

 			}

 		else if (driveNumberStr == KDriveY)

 			{

 			aDriveNumber = EDriveY;

 			}

 		else if (driveNumberStr == KDriveZ)

 			{

 			aDriveNumber = EDriveZ;

 			}

 		else

 			{

 			TInt driveNumber = 0;

 			ret = GET_OPTIONAL_INT_PARAMETER(aParameterName, aSection, driveNumber);

 			if (ret)

 				{

 				aDriveNumber = (TDriveNumber) driveNumber ;

 				}

 			}

 		}

 	return ret;

 	}