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

//

/**

@file

ABTester is both a client of the SBEngine and ABServer only for test purposes

*/

#ifndef __ABDATAOWNER_H__

#define __ABDATAOWNER_H__

#include <connect/abclient.h>

#include <e32std.h>

#include <e32property.h>

void RunActiveBackupClientL();

namespace conn

	{

	//TUid KSBEngineUid = TUid::Uid(0x10202D56);

	class CABTester;

	// The simulated file that this test DO will backup/have restored

	_LIT8(KABTestData, "Active Backup Test Base Data");

	// The simulated file that this test DO will backup/have restored

	_LIT8(KABTestProxyData, "Active Backup Test Proxy Data");

	// The simulated file that this test DO will backup/have restored

	_LIT8(KABTestDataIncrement, ":Active Backup Test Increment Data");

	// The simulated snapshot that this tets DO will backup/use to restore

	_LIT8(KABTestSnapshot, "Active Backup Test Snapshot");

	// Simulated time for initialisation of the ABDO

	const TInt KABInitTime = 5000;

	class CABData : public CBase

		{

	public:

		static CABData* NewL(TDriveNumber aDriveNum)

			{

			CABData* self = new (ELeave) CABData(aDriveNum);

			return self;

			}

		void AddDataL(TDesC8& aData)

			{

			if (!iData)

				{

				iData = HBufC8::NewL(aData.Size());

				}

			else

				{

				// Add the data to the existing buffer

				iData = iData->ReAllocL(iData->Size() + aData.Size());

				}

			iData->Des().Append(aData);

			}

		TDesC8& operator()()

			{

			return *iData;

			}

		~CABData()

			{

			delete iData;

			}

	private:		

		CABData(TDriveNumber aDriveNum) : iDriveNum(aDriveNum)	{}

	private:

		HBufC8* iData;

		TDriveNumber iDriveNum;

		};

	/**

	This class implements the callbacks defined by MActiveBackupDataClient which are used by the SBEngine 

	to request information about the backup or restore operation for this data owner

	*/		

	class CABDataOwnerCallbackImplementation : public CBase, public MActiveBackupDataClient

		{

	public:

		static CABDataOwnerCallbackImplementation* NewL(TSecureId aID);

		~CABDataOwnerCallbackImplementation();

		TBool ValidateRestoredData();

		TBool ValidateRestoredSnapshot();

	// MActiveBackupDataClient implementation

		void AllSnapshotsSuppliedL();

		void ReceiveSnapshotDataL(TDriveNumber aDrive, TDesC8& aBuffer, TBool aLastSection);

		TUint GetExpectedDataSize(TDriveNumber aDrive);

		void GetSnapshotDataL(TDriveNumber aDrive, TPtr8& aBuffer, TBool& aFinished);

		void InitialiseGetBackupDataL(TDriveNumber aDrive);

		void GetBackupDataSectionL(TPtr8& aBuffer, TBool& aFinished);

		void InitialiseRestoreBaseDataL(TDriveNumber aDrive);

		void RestoreBaseDataSectionL(TDesC8& aBuffer, TBool aFinished);

		void InitialiseRestoreIncrementDataL(TDriveNumber aDrive);

		void RestoreIncrementDataSectionL(TDesC8& aBuffer, TBool aFinished);

		void RestoreComplete(TDriveNumber aDrive);

		void TerminateMultiStageOperation();

		TUint GetDataChecksum(TDriveNumber aDrive);

		void SetABClient(CActiveBackupClient* aABClient);

		void InitialiseGetProxyBackupDataL(TSecureId aSID, TDriveNumber aDrive);

		void InitialiseRestoreProxyBaseDataL(TSecureId aSID, TDriveNumber aDrive);

	private:

		CABDataOwnerCallbackImplementation(TSecureId aID);

		void WaitForMillisecondsL(TInt aMilliseconds);

		void FillBuffer(TDes8& aDes, TBool& aFinished);

	private:

		CActiveBackupClient* iABClient;

		TBackupIncType iBackupIncType;

		TVersion iVersion;

		CABData* iSnapshot;

		CABData* iData;

		TBool iProxy;

		TInt iOffset;

		TInt iSourceSize;

		TUint iFillChar;

		TSecureId iID;

		};

	/**

	This class is the actual data owner that prepares data to send to the sbengine. It owns the CABClient 

	and passes in the callback interface implementation object

	*/	

	class CABDataOwner : public CActive

		{

	public:

		static CABDataOwner* NewL();

		void StartL();

		void RunL();

		TInt RunError(TInt aError);

		void DoCancel();

		~CABDataOwner();

	private:

		void CheckStatusL();

		CABDataOwner() : CActive(EPriorityNormal) {}

		void ConstructL();

		void Subscribe();

	private:

		/** P&S */

		RProperty iProperty;

		/** Callback implementation */

		CActiveBackupClient* iABClient;

		/** Callback implementation */

		CABDataOwnerCallbackImplementation* iCallback;

		/** Secure ID of the process */

		TSecureId iID;

		};

	}

#endif //__ABDATAOWNER_H__