/*

* Copyright (c) 2003 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:  Logger manager with read access to history files.

*

*/

#ifndef __CCALOGGERMANAGER_H__

#define __CCALOGGERMANAGER_H__

//  INCLUDES

#include <f32file.h>

#include <s32file.h>

#include "MCALoggerReadInterface.h"

#include "MCALoggerWriteObserver.h"

// FORWARD DECLARATIONS

class MCALoggerMessageFactory;

// CLASS DECLARATION

/**

 *  Logger manager with read access to history files.

 *

 *  @lib CALogger.dll

 *  @since 2.1

 */

class CCALoggerManager : 	public CBase,

            public MCALoggerReadInterface,

            public MCALoggerWriteObserver

    {

    public:

        /**

         *	Destructor.

         *	Closes filesession. Resets toc and write arrays.

         */

        virtual ~CCALoggerManager();

    protected:

        /**

         * Two-phased constructor. Creates instance to CCALoggerManager

         *	Can leave if there is no enough memory.

         *	Can leave if Dll::SetTls call fails.

         *	@return Instance to CCALoggerManager

         */

        static CCALoggerManager* NewL();

        /**

         * C++ default constructor.

         */

        CCALoggerManager();

        /**

         * By default Symbian 2nd phase constructor is private.

         */

        void ConstructL();

    private:	//new methods

        /**

         *	Get instance of CCALoggerManager

         *	If instance is not yet created, creates instance.

         *	Sets message factor if passed.

         *	Reads toc file if not yet read and if messagefactory is set.

         *	@since 2.1

         *  @param aMessageFactory Factory which is used for message and header

         *							creation.

         *  @param aCreate tells if instance should be created or not if not exists.

         *	@return Singleton instance of CCALoggerManager

         */

        static CCALoggerManager* InstanceL(

            MCALoggerMessageFactory* aMessageFactory,

            TBool aCreate = ETrue , TBool aNotFirstTime = ETrue );

        /**

         *	Get suitable filename. Check situation and updates suitable

         *  filename.

         *	If latest filename is checked before, just add one to current

         *	number. Otherwise check out directory contents and see which

         *	is last file number used.

         *	@since 2.1

         */

        void SuitableLogFileNameL();

        /**

         *	Read header information from toc file and updates toc file

         *	to contain only those headers that points to files that exists.

         *	If message factory does not exists. This call does nothing.

         *	Leaves if some other error than KErrNotFound in file open rutine.

         *	Leaves if error happens when header is tried to append to array.

         *	Leaves if toc filename rename fails

         *	Leaves if leaves if new toc file creation fails.

         *	Leaves if memory check fails with KErrDiskFull

         *	@since 2.1

         */

        void ReadTocFileL( TBool aFirstTime );

        /**

         *	Append new header to toc file. Creates file if not exists.

         *	Leaves if file open and creation fails.

         *	Leaves if memory check fails with KErrDiskFull

         *	@since 2.1

         *	@param aHeader New header information which will be written

         *  @param aTemporary ETrue, and we are saving temporary toc file.

         *                    EFalse and we are saving real toc file.

         */

        void WriteTocFileL( MCALoggerMessageHeader& aHeader,

                            TBool aTemporary = EFalse );

        /**

         *	Read information from message file.

         *	Leaves if message factory is not set with KErrNotReady

         *	Leaves if history file cannot be opened.

         *	Leaves if message append to array fails.

         *	@since 2.1

         *	@param aMessageArray Client provides array for messages read from

         *			file. Messages are appended to array.

         *	@param aKey File to be read is recognized by header. Pointer to

         *				aKey reference is used for task.

         */

        void ReadMessageFileL(

            RPointerArray< MCALoggerMessage >& aMessageArray,

            MCALoggerMessageHeader& aKey );

        /**

         *	Checks if header already exists

         *	Users aHeaders FilenameL method for key to check

         *	@since 2.5

         *	@param aHeader Checked header

         *	@return ETrue if exists, EFalse if not.

         */

        TBool CheckIfHeaderExistsL( MCALoggerMessageHeader& aHeader );

        /**

         *

         */

        void PopulateTocArrayL( RPointerArray< MCALoggerMessageHeader >& aArray,

                                const TDesC& aTocFilename

#ifdef RD_MULTIPLE_DRIVE

                                , TBool aFirstTime

#endif

                              );

        /**

        *    Leave if file operation return code is KErrDiskFull.

        *    @param aErrorCode is file operation return code.

        */

        void LeaveIfDiskFull( TInt aErrorCode );

    public:	//new methods

        /**

         *	Get read interface to history data. Client cannot delete instance.

         *	Leaves if instance call fails.

         *	@since 2.1

         *  @param aMessageFactory Factory which is used for message and header

         *							creation.

         *	@return Pointer to instance of CCALoggerManager

         */

        static MCALoggerReadInterface* ReadInstanceL(

            MCALoggerMessageFactory* aMessageFactory, TBool aFirstTime = EFalse );

        /**

         *	Creation of write instance to history data

         *	Leaves if instance call fails.

         *	Leaves if creation of CCALoggerWriter fails.

         *	@since 2.1

         *  @param aMessageFactory Factory which is used for message and header

         *							creation.

         *	@return Pointer to new created CCALoggerWriter. Ownership is

         *					transferred to the caller.

         */

        static MCALoggerWriteInterface* WriteInstanceL(

            MCALoggerMessageFactory* aMessageFactory );

        /**

         *	Releases instance. This is only for testing purposes.

         *	Sets Dll::Tls to NULL.

         *	Leaves if instance call fails.

         */

        static void ReleaseInstanceL();

    public:	//	Inherited from MCALoggerWriteObserver

        /**

         *	Add file to write buffer. TFileRelation contains two pointer.

         *	MCALoggerMessageHeader and MCALoggerWriteInterface

         *	Ownership of MCALoggerMessageHeader is transfered to this class

         *	Ownership of MCALoggerWriteInterface will stay in caller.

         *	Calls first RemoveFileL with MCALoggerWriteInterface parameter

         *	to be sure that there is no other file in write array for

         *	MCALoggerWriteInterface. Then appends TFileRelation parameter to

         *	array.

         *	Leaves if TPointerArray::Append fails.

         *	@since 2.1

         *	@param iFile File information

         */

        void AddFileL( TFileRelation aFile );

        /**

         *	Remove file from write array and append it to toc array.

         *	After that header is written to toc file.

         *	Leaves if TPointerArray::Append fails.

         *	Leaves if header file write fails.

         *	@since 2.1

         *	@param aWriter File to be removed

         *		   is recognized with file writer pointer.

         */

        void RemoveFileL( MCALoggerWriteInterface& aWriter );

        /**

         *	Creates new filename for writer. Ownership is transfered to caller.

         *	Leaves if HBufC::NewL fails.

         *	Leaves if SuitableLogFileNameL fails.

         *	@since 2.1

         *	@return Pointer to new filename.

         */

        HBufC* CreateNewFilenameL();

#ifdef RD_MULTIPLE_DRIVE

        /**

         *	Creates new filename for writer. Ownership is transfered to caller.

         *	Leaves if HBufC::NewL fails.

         *	Leaves if SuitableLogFileNameL fails.

         *	@since 2.1

         *	@return Pointer to new filename.

         */

        HBufC* CreateNewFilenameMDL();

        /**

         *	Creates new filename for writer. Ownership is transfered to caller.

         *	Leaves if HBufC::NewL fails.

         *	Leaves if SuitableLogFileNameL fails.

         *	@since 2.1

         *	@return Pointer to new filename.

         */

        TBool GetDriveStatusL( const TDriveNumber aDriveNumber );

#endif

        /**

         *	Checks memory situation. Check if there is enough memory to write

         *	file.

         *	Leaves if SysUtil::FFSSPaceGBelowCriticalLevelL fails.

         *	@since 2.1

         *	@param aMemoryRequired Memory required in bytes.

         *	@return ETrue if there is enough memory and EFalse if not.

         */

        TBool CheckMemoryL( TInt aMemoryRequired );

    public:	//Inherited from MCALoggerReadInterface

        /**

         *	Client gets pointer to message header array trough parameter.

         *	@since 2.1

         *	@param aHeaderArray Pointer to message header array is set to this

         *						parameter. Ownership of array does not change.

         */

        void GetLoggerMessageHeaderArray(

            RPointerArray< MCALoggerMessageHeader >*& aHeaderArray );

        /**

         *	Client asks logger to create messages to array concerning one header

         *	Leaves with KErrNotFound if history file does not exists.

         *	Leaves if history file read fails.

         *	@since 2.1

         *	@param aMessageArray Client provides array for messages read from

         *			file. Messages are appended to array.

         *	@param aKey File to be read is recognized by header. Pointer to

         *				aKey reference is used for task.

         */

        void CreateLoggerMessagesL(

            RPointerArray< MCALoggerMessage >& aMessageArray,

            MCALoggerMessageHeader& aKey  );

        /**

         *	Delete one history file recognized by header.

         *	Leaves if MCALoggerMessageHeader::FileNameL fails.

         *	WARNING: header passed will be deleted and removed from header

         *	array. Array is same that client has been given to with

         *	GetLoggerMessageHeaderArray so removal will be seen directly in

         *	client side too.

         *	@since 2.1

         *	@param aKey File to be read is recognized by header. Pointer to

         *				aKey reference is used for task.

         */

        void DeleteHistoryFileL( MCALoggerMessageHeader& aKey );

        /**

         *	Set message factory. Factory is used to create messages and message

         *	headers for logger and client use.

         *	@since 2.1

         *	@param aMessageFactory Pointer to message factory.

         */

        void SetLoggerMessageFactory(

            MCALoggerMessageFactory* aMessageFactory );

    private:

        /**

         *	Reference to message factory for creation messages and files

         *  when needed. Does not own.

         */

        MCALoggerMessageFactory* iMessageFactory;

        /**

         *	List of those files which have been created for writing, but not

         *	yet ready ones.

         */

        RArray< TFileRelation > iWriteFileArray;

        /**

         *	List of those files which have been created for writing, but not

         *	yet ready ones.

         */

        RPointerArray< MCALoggerMessageHeader > iFileTocArray;

        /**

         *	Temp list for toc file. Member variable for leave simpler error management.

         *  eg. leaves.

         */

        RPointerArray< MCALoggerMessageHeader > iFileTempTocArray;

        /**

         *	We have checked latest possible file name number to give FileWriter.

         */

        TBool iWeHaveLatestFileNameNumber;

        /**

         *	Latest file name number to give FileWriter when asked.

         */

        TInt iLatestFileNameNumber;

        /**

         *	File Session for handling files.

         */

        RFs iFileSession;

        /**

         *	Table of contents. Header information of history files.

         */

        TBool iTocFileRead;

    };

#endif      // __CCALOGGERMANAGER_H__

// End of File