// 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

 @released

*/

#include "t_burteststepbase.h"

namespace bur_ts

	{

	_LIT(KTabText, "\t|");

	_LIT(KFormatText2, "%S%S");

	_LIT(KFormatText3, "%S%S%S");

	_LIT(KFormatText4, "%S%S%d");

	_LIT(KFormatText5, "%S%S%X");

	_LIT(KFormatText6, "%S%S%s");

	const TUint8 KMaxHexLength = 8;

	CBURTestStepBase::CBURTestStepBase(CBURTestServer& aParent) 

		/**

		C++ Constructor

		@internalComponent

		@released

		@param aParent - The parent CBURTestServer of this child test step.

		*/

		:iParentTestServer(aParent),

		iBackupClient(NULL),

		iBackupIncType(EBackupBase),

	 	iIsPartial(EFalse),

		iFailures(KErrNone),

		iStorageManager(NULL),

		iMode(EBackupMode),

		iWaitedForActive(EFalse)

		{}

	CBURTestStepBase::~CBURTestStepBase()

		/**

		C++ Destructor

		@internalComponent

		@released

		*/

		{

		iDataOwners.ResetAndDestroy();

		iDataOwners.Close();

		iSidArray.Close();

		iJidArray.Close();

		iFs.Close();

		iTransferTypes.ResetAndDestroy();

		iTransferTypes.Close();

		delete iStorageManager;

		delete iActiveScheduler;

		delete iBackupClient;

		}

	// LOGGING METHODS

	void CBURTestStepBase::Log(TUint aIndentationLevel, const TDesC& aLog)

		/**

		Logs the data inside the string as text string at aIndentationLevel.

		@internalComponent

		@released

		@param aIndentationLevel - The indentation level in the TestExecute test report.

		@param aLog - The message to be logged.

		*/

		{

		HBufC* indentation = NULL;

		indentation = GetIndentation(aIndentationLevel);

		TPtr ptr = indentation->Des();

		INFO_PRINTF3(KFormatText2, &ptr, &aLog);

		delete indentation;

		}

	void CBURTestStepBase::LogWithText(TUint aIndentationLevel, const TDesC& aLog, const TDesC& aText)

		/**

		Writes the message with a text string.

		@internalComponent

		@released

		@param aIndentationLevel - The indentation level in the TestExecute test report.

		@param aLog - The message to be logged.

		@param aText - Textual data to be logged with the main message.

		*/

		{

		HBufC* indentation = NULL;

		indentation = GetIndentation(aIndentationLevel);

		TPtr ptr = indentation->Des();

		INFO_PRINTF4(KFormatText3, &ptr, &aLog, &aText);

		delete indentation;

		}

	void CBURTestStepBase::LogWithText8(TUint aIndentationLevel, const TDesC& aLog, const TDesC8& aText)

		/**

		8-bit variant of the above

		@internalComponent

		@released

		@param aIndentationLevel - The indentation level in the TestExecute test report.

		@param aLog - The message to be logged.

		@param aText - 8-bit textual data to be logged with the main message.

		*/

		{

		HBufC* indentation = NULL;

		indentation = GetIndentation(aIndentationLevel);

		TPtr ptr = indentation->Des();

		INFO_PRINTF4(KFormatText3, &ptr, &aLog, &aText);

		delete indentation;

		}

	void CBURTestStepBase::LogWithNum(TUint aIndentationLevel, const TDesC& aLog, TInt aNum)

		/**

		Writes to the report a number along with a message.

		@internalComponent

		@released

		@param aIndentationLevel - The indentation level in the TestExecute test report.

		@param aLog - The message to be logged.

		@param aNum - Number to be printed with the log.

		*/

		{

		HBufC* indentation = NULL;

		indentation = GetIndentation(aIndentationLevel);

		TPtr ptr = indentation->Des();

		INFO_PRINTF4(KFormatText4, &ptr, &aLog, aNum);

		delete indentation;

		}

	void CBURTestStepBase::LogWithSID(TUint aIndentationLevel, const TDesC& aLog, TSecureId aSecureId)

		/**

		Writes out a TSecureId as a hexadecimal number along with a message.

		@internalComponent

		@released

		@param aIndentationLevel - The indentation level in the TestExecute test report.

		@param aLog - The message to be logged.

		@param aSecureId - A TSecureId to be printed as a hexadecimal number.

		*/

		{

		HBufC* indentation = NULL;

		indentation = GetIndentation(aIndentationLevel);

		TPtr ptr = indentation->Des();

		INFO_PRINTF4(KFormatText5, &ptr, &aLog, aSecureId.iId);

		delete indentation;

		}

	void CBURTestStepBase::LogWithChar(TUint aIndentationLevel, const TDesC& aLog, TChar aChar)

		/**

		@internalComponent

		@released

		@param aIndentationLevel - The indentation level in the TestExecute test report.

		@param aLog - The message to be logged.

		@param aChar - A single char, appended at the end of the message.

		*/

		{

		HBufC* indentation = NULL;

		indentation = GetIndentation(aIndentationLevel);

		TPtr ptr = indentation->Des();

		INFO_PRINTF4(KFormatText6, &ptr, &aLog, &aChar);

		delete indentation;

		}

	HBufC* CBURTestStepBase::GetIndentation(TInt aLevel)

		/**

		Generates a string of indentation markers (based on KIndentationMarker) the 

		level of depth specified by aLevel

		@internalComponent

		@released

		@param aLevel - Level of depth required for indentation.

		*/

		{

		HBufC* hbuf = NULL;

		// Indentation level times the length of the indentation marker, 

		// plus room for a tab and a '|'

		TInt indentationLength = aLevel * KIndentationMarker().Length() + 10;

		hbuf = HBufC::NewL(indentationLength);

		hbuf->Des().Append(KTabText);

		for(TInt i = 0; i < aLevel; ++i)

			{

			hbuf->Des().Append(KIndentationMarker);

			}

		return hbuf;

		}

	void CBURTestStepBase::CreateStorageManagerL()

		/**

		Must only be called after the user input has been processed.

		@internalComponent

		@released

		*/

		{

		iStorageManager = CStorageManager::NewL(iBackupDirName, iDriveList, this);

		}

	void CBURTestStepBase::ProcessUserOptionsL()

		/**

		This function uses TestExecute config file parsers to read in the user preferences

		from ini files

		@internalComponent

		@released

		 */

		{

		TPtrC backupDir;

		TInt isPartial = 0;

		TInt isBase = 0;

		TPtrC driveListText;

		// directory for archiving backup data

		_LIT(KBackupDirText1, "BackupDir");

		GetStringFromConfig(ConfigSection(), KBackupDirText1, backupDir);

		_LIT(KBackupDirText2, "Backup directory: ");

		LogWithText(LOG_LEVEL3, KBackupDirText2, backupDir);

		iBackupDirName.Copy(backupDir);

		// affected drives

		_LIT(KDriveListText1, "DriveList");

		GetStringFromConfig(ConfigSection(), KDriveListText1, driveListText);

		_LIT(KDriveListText2, "Drives: ");

		LogWithText(LOG_LEVEL3, KDriveListText2, driveListText);

		// extract all drives from the user input

		iDriveList = CBURTestStepBase::StringToDriveListL(driveListText);

		// create the storage handler based on the drives and backup directory

		CreateStorageManagerL();

		// full/partial backup

		_LIT(KPartialText1, "IsPartial");

		GetIntFromConfig(ConfigSection(), KPartialText1, isPartial);

		if (isPartial == 0)

			{

			iIsPartial = EFalse;

			_LIT(KPartialText2, "Full/Partial Type: Full");

			Log(LOG_LEVEL3, KPartialText2);

			} //if

		else if (isPartial == 1)

			{

			iIsPartial = ETrue;

			TSecureId sid;

			TChar ch;

			TPtrC list;

			// PARSING ID LIST //

			_LIT(KSIDList, "IDs");

			GetStringFromConfig(ConfigSection(), KSIDList, list);

			TLex sidLex(list);

			while (!sidLex.Eos())

				{

        		sidLex.Mark();

	        	ch=sidLex.Peek();

    	    	while(!sidLex.Eos() && ( ch=sidLex.Peek() ) != TChar(','))

        			sidLex.Inc();

        		if(!sidLex.TokenLength())

        			continue;

        		TPtrC pToken = sidLex.MarkedToken();

        		TLex token(pToken);

        		if (pToken.Length() <= KMaxHexLength && token.Val(sid.iId, EHex) == KErrNone)

        			{

        			iSidArray.Append(sid);

					_LIT(KFound, "ID Found in ini file: ");

					LogWithSID(LOG_LEVEL4, KFound, sid);		

        			} //if

        		else // must be a Java suite hash

        			{

        			iJidArray.Append(pToken);

        			_LIT(KJFound, "Java ID Found in ini file: ");

        			LogWithText(LOG_LEVEL4, KJFound, pToken);

        			}

        		if(ch==TChar(','))

        			sidLex.Inc();

        		sidLex.SkipSpace();

				} //while

			_LIT(KPartialText3, "Full/Partial Type: Partial");

			Log(LOG_LEVEL3, KPartialText3);

			} //if

		else

			{

			_LIT(KPartialText4, "Full/Partial Type: UNKNOWN");

			_LIT(KPartialText5, "** PLEASE USE 0 OR 1 ONLY **");

			_LIT(KPartialText6, "** Using FULL as default  **");

			Log(LOG_LEVEL4, KPartialText4);

			Log(LOG_LEVEL4, KPartialText5);

			Log(LOG_LEVEL4, KPartialText6);

			}

		// base/incremental

		_LIT(KIncrText1, "BaseOnly");

		GetIntFromConfig(ConfigSection(), KIncrText1, isBase);

		if (isBase == 1)

			{

			iBackupIncType = EBackupBase;

			_LIT(KIncrText2, "Base/Incremental Type: Base Only");

			Log(LOG_LEVEL3, KIncrText2);

			}

		else if (isBase == 0)

			{

			iBackupIncType = EBackupIncrement;

			_LIT(KIncrText3, "Base/Incremental Type: Incremental by Default");

			Log(LOG_LEVEL3, KIncrText3);

			}

		else

			{

			_LIT(KIncrText4, "Base/Incremental Type: UNKNOWN");

			_LIT(KIncrText5, "** PLEASE USE 0 OR 1 ONLY **");

			_LIT(KIncrText6, "** Using BASE as default  **");

			Log(LOG_LEVEL4, KIncrText4);

			Log(LOG_LEVEL4, KIncrText5);

			Log(LOG_LEVEL4, KIncrText6);

			}

		}

	void CBURTestStepBase::PopulateListOfDataOwnersL()

		/**

		Uses CSBEClient::ListOfDataOwnersL() to extract a list of data owners that have 

		registred for backup and restore. Populates iDataOwners.

		@internalComponent

		@released

		*/

		{

		_LIT(KTempText1, "Getting list of data owners from device");

		Log(LOG_LEVEL2,KTempText1);

		TRAPD(err, iBackupClient->ListOfDataOwnersL(iDataOwners));

		if (err != KErrNone)

			{

			_LIT(KTempText1, "Error getting list of data owners: ");

			LogWithNum(LOG_LEVEL2,KTempText1, err);

			iFailures++;

			}

		// Log

		if (iDataOwners.Count() == 0)

			{

			_LIT(KTempText3, "No data owners found.");

			Log(LOG_LEVEL3, KTempText3);

			}

		else

			{

			_LIT(KTempText4, "Number of data owners found on device: ");

			LogWithNum(LOG_LEVEL3, KTempText4, iDataOwners.Count());

			}

		}

	void CBURTestStepBase::PopulateListOfDataOwnersAsyncL()

		/**

		Uses CSBEClient::ListOfDataOwnersL() to extract a list of data owners that have 

		registred for backup and restore. Populates iDataOwners.

		@internalComponent

		@released

		*/

		{

		_LIT(KTempText1, "Getting list of data owners from device");

		Log(LOG_LEVEL2,KTempText1);

		CBURActiveObject* active = CBURActiveObject::NewL();

		CleanupStack::PushL(active);

		TRAPD(err, iBackupClient->ListOfDataOwnersL(iDataOwners, active->iStatus));

		if (err == KErrNone)

			{

			active->StartL();

			}

		if (err != KErrNone || active->Error() != KErrNone)

			{

			_LIT(KTempText1, "Error getting list of data owners: ");

			LogWithNum(LOG_LEVEL2,KTempText1, err);

			iFailures++;

			}

		CleanupStack::PopAndDestroy(active);

		// Log

		if (iDataOwners.Count() == 0)

			{

			_LIT(KTempText3, "No data owners found.");

			Log(LOG_LEVEL3, KTempText3);

			}

		else

			{

			_LIT(KTempText4, "Number of data owners found on device: ");

			LogWithNum(LOG_LEVEL3, KTempText4, iDataOwners.Count());

			}

		}

	void CBURTestStepBase::SetBURModeL(TBURPartType aBURPartType, TBackupIncType aBackupIncType)

		/**

		Uses CSBEClient::SetBURModeL() to set backup and restore settings

		@internalComponent

		@released

		@param aBURPartType - Full/Partial backup/restore.

		@param aBackupIncType - Base/Incremental backup/restore.

		*/

		{

		iBackupClient->SetBURModeL(iDriveList, aBURPartType, aBackupIncType);

		}

	void CBURTestStepBase::SetBURModeAsyncL(TBURPartType aBURPartType, TBackupIncType aBackupIncType)

		/**

		Uses CSBEClient::SetBURModeL() Asyncrhonous version to set backup and restore settings

		@internalComponent

		@released

		@param aBURPartType - Full/Partial backup/restore.

		@param aBackupIncType - Base/Incremental backup/restore.

		*/

		{

		CBURActiveObject* active = CBURActiveObject::NewL();

		CleanupStack::PushL(active);

		iBackupClient->SetBURModeL(iDriveList, aBURPartType, aBackupIncType, active->iStatus);

		active->StartL();

		User::LeaveIfError(active->Error());

		CleanupStack::PopAndDestroy(active);

		}

	void CBURTestStepBase::PrepareForPartialBURL()

		/**

		@internalComponent

		@released

		*/

		{

		TSecureId sid = NULL;

		// go through list of pids and sids

		for (TInt index = 0; index < iDataOwners.Count(); index++)

			{

			TBool notFound = ETrue;

			sid = ExtractIDL(*iDataOwners[index]);

			if (sid != NULL)

				{

				TInt position = iSidArray.Find(sid);

				if (position != KErrNotFound)

					{

					_LIT(KTempText2, "ID found in list of data owners: ");

					LogWithSID(LOG_LEVEL3, KTempText2, sid);

					notFound = EFalse;

					}

				else if (position == KErrNotFound)

					{

					notFound = ETrue;

					} // if else

				} // if

			else // possibly jid

				{

				HBufC* pSuiteHash = ExtractJavaIDL(*iDataOwners[index]);

				TPtrC suiteHash = pSuiteHash->Des();

				if (iJidArray.Find(suiteHash) != KErrNotFound)

					{

					_LIT(KTempText3, "Java ID found in list of data owners: ");

					LogWithText(LOG_LEVEL3, KTempText3, suiteHash);

					notFound = EFalse;

					}

				else // not found 

					{

					notFound = ETrue;

					}

				delete pSuiteHash;

				pSuiteHash = NULL;

				}

			if (notFound)

				{

				delete iDataOwners[index];

				iDataOwners[index] = NULL;

				iDataOwners.Remove(index);

				index--;

				}

			}

		}

	void CBURTestStepBase::SetSIDListForPartialL()

	/**

	Set the list of active data owners for partial bur

	@param aDataOwners List of data owners for partial bur

	*/

		{