/*

* Copyright (c) 2006 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 implementation.

*

*/

// ========

// INCLUDES

// ========

#include <e32std.h>

#include <f32file.h>

#include <sysutil.h>

// This takes a lot more memory to use, so it is defaulted to off.  If the code is crashing

// in DoLogLeakedObjects then uncomment this line to help find the problem.  It is most likely

// caused by a DLL that was explicitly unloaded, making the original copy of the class name

// unavailable.

// <cmail>

// #define __MAKE_COPY_OF_NAMES 

// </cmail>

// : IMPLEMENT THIS USING RDebugLog::Open/Close AND class name/object address

// This provides additional help for debugging memory leaks.  Uncomment out the following line

// in order to log all constructions/destructions from all objects from here, rather than requiring

// recompilation of all code.

//#define __LOG_CONSTRUCTION_AND_DESTRUCTION

// =========

// CONSTANTS

// =========

const TInt KDateOrTimeMaxLength=30;

_LIT( KDateTimeFormat,"%1%/1%2%/2%3 %H%:1%T%:2%S.%*C3 " );

_LIT( KUnderscore, "_" );

_LIT( KBackslash, "\\" );

_LIT8(KEndOfLineCharacters8,"\r\n");

_LIT8( KTwoColons, "::" );

_LIT8( KColonAndSpace, ": " );

const TText8 KFullStopChar8='.';

const TText8 KTabChar8='\t';

const TInt KFormattedBufferSize = 350;

const TInt KMaxTextPerLine = 150;

const TInt KMaxClassAndFuncNameLength = 35;

// ================

// INTERNAL CLASSES

// ================

// ============================================

// 8-bit formatter overflow handler

// ============================================

class TDebugLogBase8Overflow : public TDes8Overflow

{

public:

	virtual void Overflow( TDes8& aDes );

};

// ============================================

// 16-bit formatter overflow handler and buffer

// ============================================

class TDebugLogBase16Overflow : public TDes16Overflow

{

public:

	virtual void Overflow( TDes16& aDes );

};

// ============================================================

// CLogFileHandler

// This class handles a single log file for the current thread.

// Note that the filenames are the same for all log files in

// this thread, but the directory names may be different.

// ============================================================

class CLogFileHandler : public CBase

{

public:

    RPointerArray<RDebugLog> iObjects;

//#ifdef __MAKE_COPY_OF_NAMES    

    RPointerArray<HBufC8> iObjectNames;

//#endif   

    CLogFileHandler( RFs&         aFs,

                     TDes&        aFormatBuffer, 

                     TDes8&       aOutputBuffer,

                     const TDesC& aDirectoryName,

                     const TDesC& aFileName );

    virtual ~CLogFileHandler();

    // returns ETrue if this handler is the log handler for the

    // given directory

    TBool IsHandler( const TDesC& aDirectoryName );

    // returns ETrue if the log file is open and ready for writing        

	TBool ReadyToWrite();

	// tries to open the log file and sets internal flags

	// aCloseFile - set to ETrue if the file should be closed during the call

	void TryToOpenFile( TBool aCloseFile = EFalse );

	// closes the log file

    void CloseFile();

    // flushes the log file

    void Flush();

    void WriteFormat( const TDesC8&                aClassName,

                      const TDesC8&                aFuncName,

                      TRefByValue< const TDesC16 > aFmt,

                      VA_LIST&                     aList );

    void WriteFormat( const TDesC8&               aClassName,

                      const TDesC8&               aFuncName,

                      TRefByValue< const TDesC8 > aFmt,

                      VA_LIST&                    aList );

	void Write( const TDesC8&  aClassName,

                const TDesC8&  aFuncName,

                const TDesC16& aDes );

	void Write( const TDesC8& aClassName,

                const TDesC8& aFuncName,

                const TDesC8& aDes );

	void HexDump( const TDesC8& aClassName,

                  const TDesC8& aFuncName,

                  const TDesC8& aBuffer );

private:

    RFile iFile;

    void WriteLineL( const TDesC8& aDes );

    void WriteLineL( const TDesC16& aDes );

    void AddTimestampToOutputBufferL();

    void AddClassAndFunctionToOutputBufferL( const TDesC8& aClassName,

                                             const TDesC8& aFuncName );

    RFs&         iFs;

    TDes&        iFormatBuffer;

    TPtr8        iFormatBuffer8;

    TDes8&       iOutputBuffer;

    const TDesC& iDirectoryName;

    const TDesC& iFileName;

    TBool        iTryToOpenFile;

    TBool        iFileIsOpen;

    TBool        iFirstTime;

}; // END CLogFileHandler

// ================================================================

// CDebugLogTlsData

// This class is the singleton object that manages all instances of

// the log file handler for the current thread.

// ================================================================

class CDebugLogTlsData : private CActive

{

public:

    static CLogFileHandler* GetLogFileHandler( const TDesC& aDirectory, RDebugLog* aObject );

    static void ReleaseLogFileHandler( CLogFileHandler* aHandler, RDebugLog* aObject );

    static CDebugLogTlsData* Instance();

    static void FreeIfNecessary();

    static void LogLeakedObjects();

private:    

    CDebugLogTlsData();

    TBool Initialize();

    virtual ~CDebugLogTlsData();

    CLogFileHandler* DoGetLogFileHandler( const TDesC& aDirectory, RDebugLog* aObject );

    void DoReleaseLogFileHandler( CLogFileHandler* aHandler, RDebugLog* aObject );

    void DoLogLeakedObjects();

	// inherited from CActive

	void RunL();

	void DoCancel();

    RFs                            iFs;

    TFileName                      iFileName;

    RPointerArray<CLogFileHandler> iFiles;    

    TBuf<KFormattedBufferSize>     iFormatBuffer;

   	TBuf8<KMaxTextPerLine+2>       iOutputBuffer;  // two extra bytes for end of line characters

}; // END CDebugLogTlsData

// ======================

// METHOD IMPLEMENTATIONS

// ======================

// ==========================================================================

// METHOD:  Constructor

//

// DESIGN:  

// ==========================================================================

EXPORT_C RDebugLog::RDebugLog()

    {

    iLogFileHandler = NULL;

    } // END RDebugLog

// ==========================================================================

// METHOD:  CleanupClosePushL

//

// DESIGN:  

// ==========================================================================    

EXPORT_C void RDebugLog::CleanupClosePushL()

    {

    CleanupStack::PushL( TCleanupItem(&RDebugLog::StaticClose, this) );

    } // END CleanupClosePushL

// ==========================================================================

// METHOD:  Open

//

// DESIGN:  Initialize this object.

// ==========================================================================

EXPORT_C void RDebugLog::Open( const TDesC&  aLogDirectory,

                               const TDesC8& aClassName8,

                               TAny*         aObjectAddress )

    {

    iObjectAddress = aObjectAddress;

    iClassName8.Set( aClassName8 );

    iLogDirectory.Set( aLogDirectory );

#ifdef DEBUG_LOG_CLOSE_BETWEEN_WRITES_AS_DEFAULT    

    iCloseBetweenWrites = ETrue;

#else

    iCloseBetweenWrites = EFalse;

#endif    

    iLogFileHandler = CDebugLogTlsData::GetLogFileHandler( aLogDirectory, this );

#ifdef __LOG_CONSTRUCTION_AND_DESTRUCTION

    if( iObjectAddress != 0 )

        {        

        const TUint bufferSize = 20;

        TBuf8<bufferSize> buf;

        _LIT8( KObjAddrFmt, "0x%x" );

        _LIT8( KDestructor, "CONSTRUCTOR" );

        buf.Format( KObjAddrFmt, iObjectAddress );

        Write( KDestructor, buf );    

        }

#endif

    if( !iLogFileHandler )

        {        

        CDebugLogTlsData::FreeIfNecessary();

        } // end if

    } // END Open

// ==========================================================================

// METHOD:  Close

//

// DESIGN:  

// ==========================================================================

EXPORT_C void RDebugLog::Close()

    {

#ifdef __LOG_CONSTRUCTION_AND_DESTRUCTION

    if( iObjectAddress != 0 )

        {        

        const TUint bufferSize = 20;

        TBuf8<bufferSize> buf;

        _LIT8( KObjAddrFmt, "0x%x" );

        _LIT8( KDestructor, "DESTRUCTOR" );

        buf.Format( KObjAddrFmt(), iObjectAddress );

        Write( KDestructor(), buf );    

        }

#endif

    if( iLogFileHandler )

        {        

        CDebugLogTlsData::ReleaseLogFileHandler( iLogFileHandler, this );

        iLogFileHandler = NULL;

        CDebugLogTlsData::FreeIfNecessary();

        } // end if

    } // END Close

// ==========================================================================

// METHOD:  Destructor

//

// DESIGN:  

// ==========================================================================

EXPORT_C RDebugLog::~RDebugLog()

    {

    if( iLogFileHandler )

        {

        // Error!  This means that Open was called, but not Close.        

        if( PrepareForWrite() )

            {        

            _LIT8( KDummyFuncName, "***" );

            _LIT8( KErrorText, "DEBUG LOG NOT CLOSED!" );

        	iLogFileHandler->Write( iClassName8, KDummyFuncName, KErrorText );

        	WriteComplete();

            } // end if

        Close();            

        }    

    } // END Destructor

// ==========================================================================

// METHOD:  SetCloseBetweenWrites

//

// DESIGN:  

// ==========================================================================

EXPORT_C void RDebugLog::SetCloseBetweenWrites( TBool aValue )

    {

   iCloseBetweenWrites = aValue;

    } // END SetCloseBetweenWrites

// ==========================================================================

// METHOD:  Write

//

// DESIGN:  

// ==========================================================================

EXPORT_C void RDebugLog::Write( const TDesC8& aFuncName8, 

                                const TDesC16& aText ) const

    {

	RDebugLog* self = const_cast<RDebugLog*>(this);

    if( self->PrepareForWrite() )

        {        

    	// Write the descriptor to the log file

    	iLogFileHandler->Write( iClassName8, aFuncName8, aText );

    	self->WriteComplete();

        } // end if            

    } // END Write

// ==========================================================================

// METHOD:  Write

//

// DESIGN:  

// ==========================================================================

EXPORT_C void RDebugLog::Write( const TDesC8& aFuncName8, 

                                const TDesC8& aText ) const

    {

	RDebugLog* self = const_cast<RDebugLog*>(this);

    if( self->PrepareForWrite() )

        {        

    	// Write the descriptor to the log file

    	iLogFileHandler->Write( iClassName8, aFuncName8, aText );

    	self->WriteComplete();

        } // end if

    } // END Write

// ==========================================================================

// METHOD:  WriteFormat

//

// DESIGN:  

// ==========================================================================

EXPORT_C void RDebugLog::WriteFormat( const TDesC8& aFuncName8, 

                                      TRefByValue< const TDesC16 > aFmt, 

                                      ... ) const

    {

	VA_LIST list;

	VA_START(list,aFmt);

	RDebugLog* self = const_cast<RDebugLog*>(this);

    if( self->PrepareForWrite() )

        {        

    	// Call WriteFormat method with argument list

    	iLogFileHandler->WriteFormat( iClassName8, aFuncName8, aFmt, list );

    	self->WriteComplete();

        } // end if

    } // END WriteFormat

// ==========================================================================

// METHOD:  WriteFormat

//

// DESIGN:  

// ==========================================================================

EXPORT_C void RDebugLog::WriteFormat( const TDesC8&                aFuncName8, 

                                      TRefByValue< const TDesC16 > aFmt,

                                      VA_LIST&                     aList ) const

    {

	RDebugLog* self = const_cast<RDebugLog*>(this);

    if( self->PrepareForWrite() )

        {        

    	// Call WriteFormat method with argument list

    	iLogFileHandler->WriteFormat( iClassName8, aFuncName8, aFmt, aList );

    	self->WriteComplete();

        } // end if

    } // END WriteFormat

// ==========================================================================

// METHOD:  WriteFormat

//

// DESIGN:  

// ==========================================================================

EXPORT_C void RDebugLog::WriteFormat( const TDesC8& aFuncName8, 

                                      TRefByValue< const TDesC8 > aFmt, 

                                      ... ) const

    {

	VA_LIST list;

	VA_START(list,aFmt);

	RDebugLog* self = const_cast<RDebugLog*>(this);

    if( self->PrepareForWrite() )

        {        

    	// Call WriteFormat method with argument list

    	iLogFileHandler->WriteFormat( iClassName8, aFuncName8, aFmt, list );

    	self->WriteComplete();

        } // end if

    } // END WriteFormat

// ==========================================================================

// METHOD:  WriteFormat

//

// DESIGN:  

// ==========================================================================

EXPORT_C void RDebugLog::WriteFormat( const TDesC8&               aFuncName8, 

                                      TRefByValue< const TDesC8 > aFmt,

                                      VA_LIST&                    aList ) const

    {

	RDebugLog* self = const_cast<RDebugLog*>(this);

    if( self->PrepareForWrite() )

        {        

    	// Call WriteFormat method with argument list

    	iLogFileHandler->WriteFormat( iClassName8, aFuncName8, aFmt, aList );

    	self->WriteComplete();

        } // end if

    } // END WriteFormat

// ==========================================================================

// METHOD:  HexDump

//

// DESIGN:  

// ==========================================================================

EXPORT_C void RDebugLog::HexDump( const TDesC8& aFuncName8,

                                  const TDesC8& aBuffer ) const

    {

	RDebugLog* self = const_cast<RDebugLog*>(this);

    if( self->PrepareForWrite() )

        {        

    	// Call WriteFormat method with argument list

    	iLogFileHandler->HexDump( iClassName8, aFuncName8, aBuffer );

    	self->WriteComplete();

        } // end if

    } // END HexDump

// ==========================================================================

// METHOD:  PrepareForWrite

//

// DESIGN:  

// ==========================================================================

TBool RDebugLog::PrepareForWrite()

    {

    if( !iLogFileHandler )

        {

        iLogFileHandler = CDebugLogTlsData::GetLogFileHandler( iLogDirectory, this );

        } // end if

    return (iLogFileHandler != NULL) && iLogFileHandler->ReadyToWrite();

    } // END PrepareForWrite

// ==========================================================================

// METHOD:  WriteComplete

//

// DESIGN:  

// ==========================================================================

void RDebugLog::WriteComplete()

    {

    if( iCloseBetweenWrites )

        {

        iLogFileHandler->CloseFile();

        }

    else