// 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_asyncbackuptransferhandler.h"

using namespace conn;

const TInt KZero = 0;

namespace bur_ts

	{

	CAsyncBackupTransferHandler* CAsyncBackupTransferHandler::NewL(CBURTestStepBase* aTestStep)

		/**

		Symbian OS Constructor

		@internalComponent

		@released

		@param aTestStep - A pointer to a CBURTestStepBackup or CBURTestStepRestore that owns this object

		@return Pointer to a newly created CAsyncBackupTransferHandler object.

		*/

		{

		CAsyncBackupTransferHandler* self = new (ELeave) CAsyncBackupTransferHandler(aTestStep);

		CleanupStack::PushL(self);

		self->ConstructL();

		CleanupStack::Pop();

		return self;

		}

	CAsyncBackupTransferHandler::CAsyncBackupTransferHandler(CBURTestStepBase* aTestStep)

		/**

		C++ Constructor

		@internalComponent

		@released

		@param aTestStep - A pointer to a CBURTestStepBackup or CBURTestStepRestore that owns this object

		*/

	: 	CActive(EPriorityStandard),

		iActiveScheduler(NULL),

	  	iCurrentIndex(KZero),

	  	iSuccess(ETrue),

	  	iTestStep(aTestStep),

	  	iID(NULL)

		{}

	void CAsyncBackupTransferHandler::ConstructL()

		/**

		Symbian OS 2nd phase Constructor

		@internalComponent

		@released

		*/

		{

		iID = HBufC::NewL(KZero);

		iActiveScheduler = new (ELeave) CActiveSchedulerWait;

		CActiveScheduler::Add(this);

		}

	CAsyncBackupTransferHandler::~CAsyncBackupTransferHandler()

		/**

		C++ Destructor

		@internalComponent

		@released

		*/

		{

		// Cancel the active object

		if (IsActive())

			{

			Cancel();

			}

		delete iID; 

		iID = 0;

		delete iActiveScheduler;

		iActiveScheduler = 0;

		}

	void CAsyncBackupTransferHandler::StartL()

		/**

		@internalComponent

		@released

		*/

		{

		iCurrentIndex = KZero;

		iSuccess = ETrue;

		ContinueL();

		iActiveScheduler->Start();

		}

	void CAsyncBackupTransferHandler::ContinueL()

		/**

		@internalComponent

		@released

		*/

		{

		// If all transfer types have been dealt with, there are no more requests 

		// to be made and hence we can stop the active scheduler:

		if (iCurrentIndex == iTestStep->TransferTypes().Count())

			{

			iActiveScheduler->AsyncStop();

			}

		else if (!IsActive())

			{

			CurrentIDL();

			TUint expectedSize = 0;

			_LIT(KCurrentSid, "Current ID: ");

			iTestStep->LogWithText(LOG_LEVEL3, KCurrentSid, *iID);

			TRAPD(err, expectedSize = iTestStep->BackupClient()->ExpectedDataSizeL(*iTestStep->TransferTypes()[iCurrentIndex]));

			if(err != KErrNone)

				{

				_LIT(KLog1e, "Request expected data size error: ");

				iTestStep->LogWithNum(LOG_LEVEL5, KLog1e, err);

				}

			_LIT(KExpSize, "Expected Data Size: ");

			iTestStep->LogWithNum(LOG_LEVEL4, KExpSize, expectedSize);		

			MakeRequestDataCallL();

			}

		else

			{

			// Being called during an active state

			User::Leave(KErrInUse);

			}

		}

	void CAsyncBackupTransferHandler::MakeRequestDataCallL()

		{

		TRAPD(err1,iTestStep->BackupClient()->RequestDataL(*iTestStep->TransferTypes()[iCurrentIndex], iStatus));

		if (err1 != KErrNone)

			{

			_LIT(KLog1, "Failed to request data for ID: ");

			iTestStep->LogWithText(LOG_LEVEL5, KLog1, *iID);

			_LIT(KLog2, "Error code: ");

			iTestStep->LogWithNum(LOG_LEVEL5, KLog2, err1);

			}						

		iStatus = KRequestPending;

		SetActive();	

		}

	void CAsyncBackupTransferHandler::RunL()

		/**

		Upon completion of the request, gets backup data from the backup server, and 

		saves it to the backup archive.

		@internalComponent

		@released

		*/

		{

		if (iStatus == KErrNone)

			{

			TBool isFinished;

			// Initialise following to NULL, or else SBEClient panics in debug builds:		

			CSBGenericTransferType* receivedType = NULL;

			TPtrC8 pData = iTestStep->BackupClient()->TransferDataInfoL(receivedType, isFinished);

			CleanupStack::PushL(receivedType);

			// no need to push it onto CleanupStack as there is no ownership transfer

			CSBGenericTransferType* currentTransfer = iTestStep->TransferTypes()[iCurrentIndex];

			if (KErrNone != (currentTransfer->Externalise()).CompareF(receivedType->Externalise()))

				{

				_LIT(KLogWrong, "The type of data requested doesn't much the received, please contact Connectivity team !");

				iTestStep->LogWithText(LOG_LEVEL3, KLogWrong, *iID);

				}

			else if (pData.Size() > 0)

				{

				TRAPD(err, iTestStep->StorageManager()->ArchiveDataL(currentTransfer, pData, isFinished));

				if (err != KErrNone)

					{

					iTestStep->StorageManager()->Reset();

					_LIT(KLog1, "Error Saving data to archive for ID: ");

					iTestStep->LogWithText(LOG_LEVEL3, KLog1, *iID);

					_LIT(KLog2, "Error code: ");

					iTestStep->LogWithNum(LOG_LEVEL3, KLog2, err);

					}

				else

					{

					_LIT(KLog3, "Number of bytes saved: ");

					iTestStep->LogWithNum(LOG_LEVEL3, KLog3, pData.Size());

					}

				}

			CleanupStack::PopAndDestroy(receivedType);

			if (isFinished)  // if not then there are more data to come, so run again on the same type

				{

				++iCurrentIndex;

				// Restart the active object to request more data:

				ContinueL();

				}

			else // continue to request data

				{

				MakeRequestDataCallL();

				}

			}

		else

			{

			User::Leave(iStatus.Int());

			}

		}

	void CAsyncBackupTransferHandler::DoCancel()

		/**

		@internalComponent

		@released

		*/

		{}

	TInt CAsyncBackupTransferHandler::RunError(TInt aError)

		/**

		This overridden method prints an error message to the TestExecute log

		and then returns with the error passed to it by the Active Scheduler.

		@internalComponent

		@released

		@param aError - Error code passed down by the Active Scheduler.

		@return The error code returned by the Active Scheduler.

		*/

		{

		++iCurrentIndex;

		_LIT(KErrorText, "Error while async call : ");

		iTestStep->LogWithNum(LOG_LEVEL4, KErrorText, aError);

		iSuccess = EFalse;

		TRAPD(err, ContinueL());

		if (err != KErrNone)

			{

			_LIT(KErrorText1, "Error trying to issue another requst : ");

			iTestStep->LogWithNum(LOG_LEVEL4, KErrorText1, err);

			}

		return KErrNone;

		}

	void CAsyncBackupTransferHandler::CurrentIDL()

		/**

		@internalComponent

		@released

		@return SecureId of the data owner currently being processed.

		*/

		{

		delete iID;

		iID = NULL;

		CSBGenericTransferType* transfer = iTestStep->TransferTypes()[iCurrentIndex];

		TSBDerivedType type = transfer->DerivedTypeL();

		TInt numberOfDigits = EHex;

		if (type == ESIDTransferDerivedType)

			{

			CSBSIDTransferType* sidType = CSBSIDTransferType::NewL(transfer);

			CleanupStack::PushL(sidType); 

			iID = HBufC::NewL(numberOfDigits);

			TPtr pID = iID->Des();

			pID.AppendNumUC(sidType->SecureIdL(), EHex);

			CleanupStack::PopAndDestroy(sidType);

			}

		else if (type == EPackageTransferDerivedType)

			{

			CSBPackageTransferType* pidType = CSBPackageTransferType::NewL(transfer);

			CleanupStack::PushL(pidType);

			iID = HBufC::NewL(numberOfDigits);

			TPtr pID = iID->Des();

			pID.AppendNum(TSecureId(pidType->PackageIdL()), EHex);

			CleanupStack::PopAndDestroy(pidType);

			}

		else if (type == EJavaTransferDerivedType)

			{

			CSBJavaTransferType* javaType = CSBJavaTransferType::NewL(transfer);

			CleanupStack::PushL(javaType);

			iID = HBufC::NewL(javaType->SuiteHashL().Length());

			TPtr pID = iID->Des();

			pID.Append(javaType->SuiteHashL());

			CleanupStack::PopAndDestroy(javaType);

			}

		}

	TBool CAsyncBackupTransferHandler::Success()

		/**

		@internalComponent

		@released

		@return Whether or not all data transfers completed successfully and resets the success.

		*/

		{

		TBool res = iSuccess;

		iSuccess = ETrue;

		return res;

		}

	}	// end namespace