/**

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

* Declaration of CDataOwnerManager

* 

*

*/

/**

 @file

*/

#ifndef __DATAOWNERMANAGER_H__

#define __DATAOWNERMANAGER_H__

// System

#include <e32base.h>

#include <connect/sbtypes.h>

#include <f32file.h>

#include <e32property.h>

#include <swi/sisregistrysession.h>

#include <badesca.h>

#include "sbeconfig.h"

#include "sbeparserproxy.h"

#include <connect/javamanagerinterface.h>

// Forwards

class CBaBackupSessionWrapper;

class CARC4;

namespace conn

	{

	// Forwards

	class CDataOwner;

	class CABServer;

	class CBufferFileReader;

	class CPackageDataTransfer;

	class CDataOwnerManager;

	class CJavaDataOwnerManager;

	class CSecureBUREncryptKeySource;

	class CSBEDecompressAndEncrypt;

    /** The current request state 

    @internalComponent

    */

    enum TState 

    	{

    	ENone, /*<! The DataOwnerManager is not requesting or supplying */ 

    	ERequest, /*<! The DataOwnerManager is currently dealing with a request */

    	ESupply, /*<! The DataOwnerManager is currently dealing with a supply */

    	EBuffer /*<! The DataOwnerManager is currently dealing with buffering */

    	};

	// Globals

	_LIT(KStar, "*");

	_LIT(KPrivate, "\\private\\");

	_LIT(KBackSlash, "\\");

	_LIT(KColon, ":");

	_LIT(KBackupRegistrationFile, "backup_registration*.xml");

	_LIT(KPrimaryBackupRegistrationFile, "backup_registration.xml");

	_LIT(KImportDir, "\\private\\10202D56\\import\\packages\\");

	/**

		Simple container to map Secure ID's to there assocaited Data Owner

		@internalComponent

	*/

    class CDataOwnerContainer : public CBase

    	{

    	public:

    		static CDataOwnerContainer* NewL(TSecureId aSid, CDataOwnerManager* apDataOwnerManager);

    		~CDataOwnerContainer();

    		static TInt Compare(const CDataOwnerContainer& aFirst, const CDataOwnerContainer& aSecond);

			static TBool Match(const CDataOwnerContainer& aFirst, const CDataOwnerContainer& aSecond);

    		TSecureId SecureId() const;

    		CDataOwner& DataOwner() const;

        private:

        	CDataOwnerContainer(TSecureId aSID);

        	void ConstructL(CDataOwnerManager* apDataOwnerManager);

    	private:

        	TSecureId       iSecureId; /*<! Contains the secure ID */

        	CDataOwner*     ipDataOwner; /*<! Contains the data owner.*/

    	};

    /** The state of the data owner manager

    @internalComponent

    */

    class TDOMState

    	{

	public:

		TState          	iState; /*<! The current state of the DataOwnerManager */

		TSecureId       	iSID; /*<! The secure ID we are currently working with */

		};

	/**

	Manager for data owners.

	@internalTechnology

	*/

	class CDataOwnerManager : public CBase

		{

	public:

	    // Construction

	    static CDataOwnerManager* NewLC();

	    ~CDataOwnerManager();

	    // Methods

	    void SetBURModeL(const TDriveList& aDriveList, TBURPartType aBURType, 

						TBackupIncType aBackupIncType);

	    void GetDataOwnersL(RPointerArray<CDataOwnerInfo>& aDataOwners);

	    void GetExpectedDataSizeL(CSBGenericTransferType* aGenericTransferType, TUint& aSize);

	    void GetPublicFileListL(CSBGenericDataType* aGenericDataType, TDriveNumber aDriveNumber, RFileArray& aFiles);

	    void GetRawPublicFileListL(CSBGenericDataType* aGenericDataType, TDriveNumber aDriveNumber, 

	    						   RRestoreFileFilterArray& aRestoreFileFilter);

	    void GetXMLPublicFileListL(TSecureId aSID, TDriveNumber aDriveNumber, HBufC*& aBuffer);

	    void SetSIDListForPartialBURL(TDesC8& aFlatArrayPtr);

	    void SIDStatusL(RSIDStatusArray& aSIDStatus);

	    void AllSnapshotsSuppliedL();

	    void GetNextPublicFileL(CSBGenericDataType* aGenericDataType, TBool aReset,

	                           TDriveNumber aDriveNumber, TEntry& aEntry);

	    // Global heap 

	    void SupplyDataL(CSBGenericTransferType* aGenericTransferType, TDesC8& aBuffer, 

	    				 TBool aLastSection);

	    void RequestDataL(CSBGenericTransferType* aGenericTransferType,

	    	    		  TPtr8& aBuffer, TBool& aLastSection);

	    // Accessors

	    void SetActiveBackupServer(CABServer* aABServer);

	    RFs& GetRFs();

	    CABServer& ABServer();

	    CDataOwner& DataOwnerL(TSecureId aSID);

	    TDriveList& DriveList();

	    TBURPartType BURType() const;

	    TBackupIncType IncType() const;

		void AllSystemFilesRestoredL();

		CSBEConfig& Config();

		inline CSBEParserProxy& ParserProxy();

		TBool IsSetForPartialL(TSecureId aSecureId) const;

	private:

		// Constructor

		void ConstructL();

		CDataOwnerManager();

		// Methods

		void FindDataOwnersL();

		CDataOwnerContainer* FindL(TSecureId aSID);

		CPackageDataTransfer* FindPackageDataContainerL(TUid pid);

		void StripSecureIdL(const TDesC& aStrip, TSecureId& aSecureId);

		void UpdateDataOwnersPartialStateL();

		void FindImportPackagesL(Swi::RSisRegistrySession& aRegistry, RPointerArray<CDataOwnerInfo>& aDataOwners);

		void FindRegistrationFilesL(const TDesC& aPath, CDesCArray& aFiles);

	private:

	    RPointerArray<CDataOwnerContainer>  iDataOwners; /*<! An array of TDataOwnerContainers */

		RPointerArray<CPackageDataTransfer> iPackageDataOwners; /*<! An array of package data transfer objects */

	    TDOMState           iState; /*!< The state of the DataOwnerManager */

	    // Current backup options (set in SetBURModeL -> needed for active clients)

	    TDriveList			iDriveList; /*<! Drive list for backup */

	    TBURPartType		iBURType; /*<! Backup/restore type */

	    TBackupIncType		iIncType; /*<! Incrementatl type */

	    // Resources

	    CABServer*          ipABServer; /*!< The active backup server */

	    RFs					iFs; /*!< A RFs used in this class and all DataOwners */

	    CBufferFileReader*	iBufferFileReader; /*<! Used to restore registration files */

	    CSBEDecompressAndEncrypt* iDecompressor;

	    /** Set to true if we need to reset the device after a restore */

	    TBool				iResetAfterRestore;

	    /** Object to handle Java data owners */

		CJavaManagerInterface* iJavaDOM;

	    /** List of Secure IDs for Partial Restore */

	    RSIDArray* iSIDListForPartial;

	    /** Config for SBE */

	    CSBEConfig* iConfig;

	    /** Base Backup Session Wrapper */

	    CBaBackupSessionWrapper* iBaBackupSession;

	    /** Backup Registration Parser Proxy */

	    CSBEParserProxy*		 iParserProxy;

		};

    inline TDriveList& CDataOwnerManager::DriveList()

    /**

    Return the list of drives specified for the operation

    @return Drivelist

    */

    	{

    	return iDriveList;

    	}

    inline TBURPartType CDataOwnerManager::BURType() const

    /**

    Return the partial backup type

    @return The partial backup type

    */

    	{

    	return iBURType;

    	}

    inline TBackupIncType CDataOwnerManager::IncType() const

    /**

    Return the incremental backup type

    @return The incremental backup type

    */

    	{

    	return iIncType;

    	}

    /**

    Return Active Backup Server

    @return reference to Active Backup Server

    */	

	inline CABServer& CDataOwnerManager::ABServer()

		{

		return *ipABServer;

		}

	/**

	Return Parser Proxy

	@return reference to Parser Proxy

	*/

	inline CSBEParserProxy& CDataOwnerManager::ParserProxy()

		{

		return *iParserProxy;

		}

	} // namespace conn

#endif // __DATAOWNERMANAGER_H__