// 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 <connect/sbtypes.h>

#include "t_teststepbackup2.h"

#include <apgcli.h>

#include <connect/javamanagerinterface.h>

namespace bur_ts

	{	

	CBURTestStepBackup2* CBURTestStepBackup2::NewL(CBURTestServer& aTestServer)

		/**

		Symbian OS Constructor

		@internalComponent

		@released

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

		@return Pointer to a newly created CBURTestStepBackup2 object.

		*/

		{

		CBURTestStepBackup2* self = new (ELeave) CBURTestStepBackup2(aTestServer);

		CleanupStack::PushL(self);

		self->ConstructL();

		CleanupStack::Pop();

		return self;

		}

	CBURTestStepBackup2::CBURTestStepBackup2(CBURTestServer& aTestServer)

		/**

		C++ Constructor

		@internalComponent

		@released

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

		*/

		: CBURTestStepBase(aTestServer), iDataTransferHandler(NULL)

		{}

	void CBURTestStepBackup2::ConstructL()

		/**

		Symbian OS 2nd-phase Constructor

		@internalComponent

		@released

		*/

		{

		TInt error;

		// Initialise the drive list to empty

		iDriveList.FillZ();

		User::LeaveIfError(iFs.Connect());

		// Install an active scheduler for this test step

		iActiveScheduler = new(ELeave) CActiveScheduler;

		CActiveScheduler::Install(iActiveScheduler);

		TRAP(error, iBackupClient = CSBEClient::NewL());

		if (error != KErrNone)

			{

			_LIT(KClientConnection, "SBEClientConnection");

			User::Panic(KClientConnection,error);

			}

		_LIT(KBURTBackup, "BURTestServerBackup");

		User::RenameThread(KBURTBackup);

		//User::SetCritical(User::ESystemCritical);

		SetTestStepName(KBURTestBackup2);

		}

	CBURTestStepBackup2::~CBURTestStepBackup2()

		/**

		C++ Destructor

		@internalComponent

		@released

		*/

		{

		delete iDataTransferHandler;

		}

	TVerdict CBURTestStepBackup2::doTestStepPreambleL()

		/**

		Override of base class virtual function

		@internalComponent

		@released

		@return TVerdict code

		*/

		{

		SetTestStepResult(EPass);

		return TestStepResult();

		}

	TVerdict CBURTestStepBackup2::doTestStepL()

		/**

		Override of base class pure virtual

		@internalComponent

		@released

		@return TVerdict code

		*/

		{

		_LIT(KLog1, "Processing user options...");

		Log(LOG_LEVEL2, KLog1);

		ProcessUserOptionsL();

		// Get a list of data owners:

		PopulateListOfDataOwnersL();

		TBURPartType type = EBURBackupFull;

		if (iIsPartial)

			{

			_LIT(KLog2, "Preparing for PARTIAL backup...");

			Log(LOG_LEVEL2, KLog2);

			type = EBURBackupPartial;

			PrepareForPartialBURL();

			SetSIDListForPartialL();

			}

		else

			{

			_LIT(KLog3, "Preparing for FULL backup...");

			Log(LOG_LEVEL2, KLog3);

			}

		CheckValidRegistrationL();

		_LIT(KLog4, "Saving Data Owners...");

		Log(LOG_LEVEL2, KLog4);

		SaveDataOwners();

		Log(LOG_LEVEL2, _L("Setting backup mode..."));

		TRAPD(err,SetBURModeL(type, iBackupIncType));

		if (err != KErrNone)

			{

			_LIT(KBURError, "Error setting Backup mode ");

			Log(LOG_LEVEL3, KBURError);

			}

		iDataTransferHandler = CAsyncBackupTransferHandler::NewL(this);

		Log(LOG_LEVEL2, _L("Starting backup..."));

		//BackupRegistrationDataL();

		BackupPublicDataL();

		BackupJavaMidletsL();

		BackupJavaMidletsDataL();

		// Backup data according to user preferences

		if (iBackupIncType == EBackupIncrement)

			{

			IncrementalBackupL();

			}

		else

			{

			BaseBackupL();

			}

		GetLargePublicFileListL();

		Log(LOG_LEVEL2, _L("Setting backup mode to Normal ..."));

		TRAPD(err2,SetBURModeL(EBURNormal, ENoBackup));

		if (err2 != KErrNone)

			{

			_LIT(KBURError, "Error setting Backup mode ");

			Log(LOG_LEVEL3, KBURError);

			}

		TestSetBURMode();

		return TestStepResult();

		}

	void CBURTestStepBackup2::BaseBackupL()

		/**

		@internalComponent

		@released

		*/

		{

		// system data

		BackupSystemBaseDataL();

		BackupSystemSnapshotDataL();

		//passive

		BackupPassiveBaseDataL();

		BackupPassiveSnapshotDataL();

		}

	void CBURTestStepBackup2::IncrementalBackupL()

		/**

		@internalComponent

		@released

		*/

		{

		_LIT(KInc, "Backup mode: INCREMENTAL");

		Log(LOG_LEVEL2, KInc);

		//active

		SupplySystemSnapshotDataL();

		SupplyActiveSnapshotDataL();

		SupplyPassiveSnapshotDataL();

		TRAPD(err,iBackupClient->AllSnapshotsSuppliedL());

		if (err != KErrNone)

			{

			_LIT(KSnapErr, "Error Supplying Snapshot Data ");

			LogWithNum(LOG_LEVEL3, KSnapErr, err);

			}

		else

			{

			_LIT(KSnap, "All Snapshots Supplied");

			Log(LOG_LEVEL3, KSnap);

			}

		// system data

		BackupSystemBaseDataL();

		BackupSystemSnapshotDataL();

		//passive

		BackupPassiveIncDataL();

		BackupPassiveSnapshotDataL();

		}

	void CBURTestStepBackup2::BackupSystemBaseDataL()

		/**

		@internalComponent

		@released

		*/

		{

		_LIT(KLog, "Backup System Data ...");

		Log(LOG_LEVEL2, KLog);

		GeneratePIDTransferTypesL(iTransferTypes, ESystemData);

		DoBackupL();

		}

	void CBURTestStepBackup2::SupplyDataL(RTransferTypeArray& aTransferTypes, TRequestStatus& aStatus)

		{//added for coverage test

		TInt transferTypesCount = aTransferTypes.Count();

		for(TInt currentIndex = 0; currentIndex < transferTypesCount; ++currentIndex)

			{

			TInt error;		

			TInt increments = 0;

			TInt incrIndex = 1;

			TSBDerivedType dataType = aTransferTypes[currentIndex]->DerivedTypeL();

			// check for incremental data

			switch(dataType)

				{

				case ESIDTransferDerivedType:

					{

					CSBSIDTransferType* type = CSBSIDTransferType::NewL(aTransferTypes[currentIndex]);

					CleanupStack::PushL(type);

					_LIT(KSid, "Supplying data for ID: ");

					LogWithSID(LOG_LEVEL3, KSid, type->SecureIdL());

					if (type->DataTypeL() == EActiveIncrementalData || type->DataTypeL() == EPassiveIncrementalData)

						{

						increments = iStorageManager->TotalIncFiles(type);

						if (!increments)

							{

							_LIT(KErrorText2, "No increments found");

							Log(LOG_LEVEL4, KErrorText2);

							// cleanup

							CleanupStack::PopAndDestroy(type);

							continue;

							}

						else 

							{

							_LIT(KIncFound, "Number of increments found: ");

							LogWithNum(LOG_LEVEL4, KIncFound, increments);

							} // else if

						} // if

					CleanupStack::PopAndDestroy(type);

					}

					break;

				case EPackageTransferDerivedType:

					{

					// package stuff

					CSBPackageTransferType* pType = CSBPackageTransferType::NewL(aTransferTypes[currentIndex]);

					CleanupStack::PushL(pType);

					_LIT(KPid, "Supplying data for Package ID: ");

					LogWithSID(LOG_LEVEL3, KPid, pType->PackageIdL());

					CleanupStack::PopAndDestroy(pType);

					}

					break;

				case EJavaTransferDerivedType:

					{

					// java stuff

					CSBJavaTransferType* jType = CSBJavaTransferType::NewL(aTransferTypes[currentIndex]);

					CleanupStack::PushL(jType);

					_LIT(KJid, "Supplying data for Java SuiteHash: ");

					LogWithText(LOG_LEVEL3, KJid, jType->SuiteHashL());

					CleanupStack::PopAndDestroy(jType);

					}

					break;

				} // switch

			TBool runAgain = ETrue;		

			do 

				{

				TBool finished;				

				TPtr8* bufferPtr = NULL;

				TRAP(error, bufferPtr = &iBackupClient->TransferDataAddressL());

				if (error != KErrNone)

					{

					_LIT(KErrTDA, "Error getting TransferDataAddress: ");

					LogWithNum(LOG_LEVEL4, KErrTDA, error);

					break;

					}

				TRAP(error, iStorageManager->RetrieveDataL(aTransferTypes[currentIndex], *bufferPtr, finished, incrIndex));

				if (error != KErrNone)

					{

					iStorageManager->Reset();

					if (error == KErrPathNotFound || error == KErrNotFound)

						{

						_LIT(KErrorText2, "Data doesn't exists");

						Log(LOG_LEVEL4, KErrorText2);

						}

					else

						{

						_LIT(KErrorText1, "Error reading from archive: ");

						LogWithNum(LOG_LEVEL4, KErrorText1, error);

						iFailures++;

						}

					break;

					} 

				else

					{

					_LIT(KLogBytes, "Number of bytes to send: ");

					LogWithNum(LOG_LEVEL4, KLogBytes, bufferPtr->Length());	

					TRAP(error, iBackupClient->SupplyDataL(*aTransferTypes[currentIndex], finished, aStatus));

					if (error != KErrNone)

						{

						_LIT(KErrorText2, "Error supplying data to backup server: ");

						LogWithNum(LOG_LEVEL4, KErrorText2, error);

						if (iExpectStatus != error)

							iFailures++;

						break;

						}

					else

						{

						_LIT(KSuccess, "Operation finished successfully");

						Log(LOG_LEVEL4, KSuccess);

						}

					} // else

				if ((finished && !increments) || (incrIndex == increments && finished)) // if finished 

					{

					runAgain = EFalse;

					}

				else if (finished && incrIndex < increments) // is incremental data move to next increment

					{

					incrIndex++;

					runAgain = ETrue;

					}

				else 

					{

					runAgain = ETrue;

					}

				} // do

				while (runAgain);

			} // for

			if (!iFailures)

				{

				_LIT(KComp, "No errors found");

				Log(LOG_LEVEL3, KComp);

				}

		// Do not delete bufferPtr, as it gets deleted by the iBackupClient

		}

	void CBURTestStepBackup2::SupplySystemSnapshotDataL()

		/**

		@internalComponent

		@released

		*/

		{

		GeneratePIDTransferTypesL(iTransferTypes, ESystemSnapshotData);

		// go through each of them and check if we have snapshot to supply

		if (iTransferTypes.Count())

			{

			_LIT(KLog, "Supply System Snapshot Data ...");

			Log(LOG_LEVEL2, KLog);

			TRequestStatus status;

			SupplyDataL(iTransferTypes, status);

			}

		}

	void CBURTestStepBackup2::BackupSystemSnapshotDataL()

		/**

		@internalComponent

		@released

		*/

		{

		_LIT(KLog, "Backup System Snapshot Data ...");

		Log(LOG_LEVEL2, KLog);

		GeneratePIDTransferTypesL(iTransferTypes, ESystemSnapshotData);

		DoBackupL();

		}

	void CBURTestStepBackup2::BackupRegistrationDataL()

		/**

		@internalComponent

		@released

		*/

		{

		_LIT(KReg, "Backup registration data...");

		Log(LOG_LEVEL2, KReg);

		GenerateSIDTransferTypesL(iTransferTypes, ERegistrationData);

		DoBackupL();

		}

	void CBURTestStepBackup2::BackupPassiveSnapshotDataL()

		/**

		@internalComponent

		@released

		*/

		{

		_LIT(KPassSnap, "Backup passive snapshot data...");

		Log(LOG_LEVEL2, KPassSnap);

		GenerateSIDTransferTypesL(iTransferTypes, EPassiveSnapshotData);

		DoBackupL();

		}

	void CBURTestStepBackup2::SupplyPassiveSnapshotDataL()

		/**

		@internalComponent

		@released

		*/

		{

		_LIT(KSupp, "Supplying passive snapshot data...");

		Log(LOG_LEVEL2, KSupp);

		DoSupplyL(EPassiveSnapshotData);

		}

	void CBURTestStepBackup2::BackupPassiveBaseDataL()

		/**

		@internalComponent

		@released

		*/

		{

		_LIT(KPassBase, "Backup passive base data...");

		Log(LOG_LEVEL2, KPassBase);

		GenerateSIDTransferTypesL(iTransferTypes, EPassiveBaseData);

		DoBackupL();

		}

	void CBURTestStepBackup2::BackupPassiveIncDataL()

		/**

		@internalComponent

		@released

		*/

		{

		_LIT(KPassInc, "Backup passive incremental data...");

		Log(LOG_LEVEL2, KPassInc);

		GenerateSIDTransferTypesL(iTransferTypes, EPassiveIncrementalData);

		DoBackupL();

		}

	void CBURTestStepBackup2::BackupActiveSnapshotDataL()

		/**

		@internalComponent

		@released

		*/

		{

		_LIT(KActSnap, "Backup active snapshot data...");

		Log(LOG_LEVEL2, KActSnap);

		DoActiveBackupL(EActiveSnapshotData);

		}

	void CBURTestStepBackup2::SupplyActiveSnapshotDataL()

		/**

		@internalComponent

		@released

		*/

		{

		_LIT(KSuppActSnap,"Supplying active snapshot data...");

		Log(LOG_LEVEL2, KSuppActSnap);

		DoSupplyL(EActiveSnapshotData);

		}

	void CBURTestStepBackup2::BackupActiveBaseDataL()

		/**

		@internalComponent

		@released

		*/

		{

		_LIT(KActBase, "Backup active base data...");

		Log(LOG_LEVEL2, KActBase);

		DoActiveBackupL(EActiveBaseData);

		}