/**

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

* Declaration of Classes used to handle buffers

* 

*

*/

/**

 @file

*/

#ifndef __SBEBUFFERHANDLER_H__

#define __SBEBUFFERHANDLER_H__

#include <e32base.h>

#include <f32file.h>

#include <connect/sbtypes.h>

#include <badesca.h>

namespace conn

	{

	const TInt KDesCArrayGranularity = 8;

	/**

	This class defines the interface required to validate backup/restore data

	@internalTechnology

	*/

	class MValidationHandler

		{

	public:

		/**

		This method will check if the file name is in the 

		list of the files to be restored/backuped up

		@param aFileName reference to the filename to check

		@return ETrue if file to backup/restore is valid

		*/

		virtual TBool ValidFileL(const TDesC& aFileName) = 0;

		};

	/** Temporary path used for restoring midlets

	@internalTechnology

	*/

	_LIT(KMIDletTempRestorePath, "C:\\system\\temp\\MIDletRestore\\");

	/* Reads a fixed size object from a buffer

	@internalTechnology

	*/

	template<class T>

	TBool ReadFromBufferF(T& aT, TUint8*& appCurrent, const TUint8* apEnd);

	/* Reads a vairable size object from a buffer

	@internalTechnology

	*/

	TBool ReadFromBufferV(TPtr8& aT, TInt aSize, TUint8*& appCurrent,

						  const TUint8* apEnd);

	/** Simple class to wrap up the fixed elements for a snapshot.

	@internalTechnology

	*/

	class TSnapshot

		{

	public:

		TSnapshot()

		/** Standard C++ Constructor.

		*/

			{

			}

		TSnapshot(const TDesC& aFileName, TInt64 aModified) :

			iFileName(aFileName), iModified(aModified)

		/** Standard C++ Constructor.

		@param aFileName name of file

		@param aModified modification attribute of file

		*/

			{

			}

	public:

		TFileName	iFileName; /*<! Filename */

		TInt64		iModified; /*<! The modified time of the file */

		};

	/** Simple class to store snapshot file

        @internalComponent

	*/

	class CSnapshot : public CBase

		{

	public:

		static CSnapshot* NewLC(const TInt64& aModified, const TDesC& aFileName);

		static CSnapshot* NewLC(const TSnapshot& aSnapshot);

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

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

		~CSnapshot();

		const TInt64& Modified() const;

		const TDesC& FileName() const;

		void Snapshot(TSnapshot& aSnapshot);

	private:

		CSnapshot(const TInt64& aModified);

		void ConstructL(const TDesC& aFileName);

	private:

    	TInt64				iModified; /*<! The type of the selection */

    	HBufC*		       	iFileName; /*<! The actual selection */

		};

	/** Simple array of TSnapshot

	@internalTechnology

	*/

	typedef RPointerArray<CSnapshot> RSnapshots;

	/** Simple class to wrap up the fixed elements for a file.

	@internalComponent

	*/

	class TFileFixedHeader

		{

	public:

		TFileFixedHeader()

		/** Standard C++ constructor

		*/

			{

			}

		TFileFixedHeader(const TUint aFileNameLength, TUint aFileSize, 

						 TUint aAttributes, TInt64 aModified) :

			iFileNameLength(aFileNameLength), iFileSize(aFileSize), iAttributes(aAttributes), iModified(aModified)

		/** Standard C++ constructor

		*/

			{

			}

	public:

		TUint	iFileNameLength; /*<! The length of the name of the current file */

		TUint	iFileSize; /*<! The length of the current file */

		TUint	iAttributes; /*<! The attributes for the file */

		TInt64	iModified; /*<! The modifed time for the file */

		}; 

	/** Class to write one or more files to a memory buffer

	@internalTechnology

	*/

	class CBufferFileWriter : public CBase

		{

	public:

		// Constructors

		static CBufferFileWriter* NewL(RFs& aFs, CDesCArray* aFileNames);

		~CBufferFileWriter();

		// Methods

		void StartL(TPtr8& aBuffer, TBool& aCompleted);

		void ContinueL(TPtr8& aBuffer, TBool& aCompleted);

		void WriteToBufferL(TPtr8& aBuffer, TBool& aCompleted);

	private:

		// Constructors

		CBufferFileWriter(RFs& aFs, CDesCArray* aFileNames);

		void ConstructL();

	private:

		RFs&				iFs; /*<! File server to use */

		CDesCArray*			iFileNames; /*<! Array of files to write to the buffer */

		// State

		RFile				iFileHandle; /*<! File handle of current file writing to buffer */

		TBool				iFileOpen; /*<! Is the file open */

		TInt				iCurrentFile; /*<! Current file we are writing -> offset into array */

		TInt				iOffset; /*<! Offset into file to start writing from */

		TBool				iHeaderWritten; /*<! Has the header been written */

		TBool				iFileNameWritten; /*<! Have we written the filename? */

		}; // CBufferFileWriter

	/** Class to read one or more files from a memory buffer to disk

	@internalTechnology

	*/

	class CBufferFileReader : public CBase

		{

	public:

		// Constructors

		static CBufferFileReader* NewL(RFs& aFs, RSnapshots* aSnapshots = NULL, MValidationHandler* aValidationHandler = NULL);

		~CBufferFileReader();

		// Methods

		void StartL(const TDesC8& aBuffer, TBool aLastSection);

		void ContinueL(const TDesC8& aBuffer, TBool aLastSection);

		void ReadFromBufferL(const TDesC8& aBuffer, TBool aLastSection);

		void ReadMIDletsFromBufferL(const TDesC8& aBuffer, TBool aLastSection, 

			CDesCArray& aUnpackedFileNames);

		void Reset();

	private:

		// Constructors

		CBufferFileReader(RFs& aFs, RSnapshots* aSnapshots, MValidationHandler* aValidationHandler);

		void CheckFileInSnapshotL();

		void RecreateDirL();

		void RecreateFileL();

		TBool WriteToFileL(TUint8*& aCurrent, const TUint8* aEnd);

		void RedirectMIDletRestorePathL(const TDesC& aOriginal, CDesCArray& aRedirected);

	private:

		TFileFixedHeader iFixedHeader; 

		RFs&				iFs; /*<! File server to use */

		RSnapshots*			iSnapshots; /*<! Snapshot used to detect deleted files */

		// State

		TBool				iFixedHeaderRead; /*<! Have we read the fixed header? */

		TBool				iFileNameRead; /*<! Have we read the filename? */

		TBool				iSnapshotChecked; /*! Have we checked the snapshot */

		TBool				iRestore; /*<! Are we skipping the bytes are restoring them? */

		TInt				iLeftToSkip; /*<! If we are skipping data, how much is left? */

		TFileName			iFileName; /*<! The file name */

		RFile				iFileHandle; /*<! The file handle */

		TBool				iFileOpen; /*<! Is the file open? */

		MValidationHandler* iValidationHandler; /*<! Handler to Validation Implementation */

		TUint				iBytesRead; /*<! Number of bytes Read */

		}; // CBufferFileReader

	/** Class to write snapshot data to a memory buffer

	@internalTechnology

	*/

	class CBufferSnapshotWriter : public CBase

		{

	public:

		// Constructors

		static CBufferSnapshotWriter* NewL(RSnapshots* aSnapshot);

		~CBufferSnapshotWriter();

		// Methods

		void StartL(TPtr8& aBuffer, TBool& aCompleted);

		void ContinueL(TPtr8& aBuffer, TBool& aCompleted);

	private:

		// Constructors

		CBufferSnapshotWriter(RSnapshots* aSnapshot);

		void ConstructL();

		void WriteToBufferL(TPtr8& aBuffer, TBool& aCompleted);

	private:

		// Files

		RSnapshots*			iSnapshots; /*<! List of files */

		// State

		TInt				iCurrentSnapshot; /*<! Current file writing */

		}; // CBufferSnapshotWriter

	/** Class to read snapshot data from a memory buffer

	@internalTechnology

	*/

	class CBufferSnapshotReader : public CBase

		{

	public:

		// Constructors

		static CBufferSnapshotReader* NewL(RSnapshots& aSnapshots);

		~CBufferSnapshotReader();

		// Methods

		void StartL(const TDesC8& aBuffer, TBool aLastSection);

		void ContinueL(const TDesC8& aBuffer, TBool aLastSection);

	private:

		// Constructor

		CBufferSnapshotReader(RSnapshots& aSnapshots);

		void ReadFromBufferL(const TDesC8& aBuffer, TBool aLastSection);

	private:

		// Files

		RSnapshots&			iSnapshots; /*<! Build up list of files here */

		// State

		TSnapshot				iSnapshot; /*<! The fixed header */

		}; // CBufferSnapshotReader

	} // namespace

#endif // __SBEBUFFERHANDLER_H__