/*

* Copyright (c) 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:

*

*/

#include "cradioenginelogger.h"

#include "cradioenginetls.h"

// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------

// Return the logger instance.

// ---------------------------------------------------------------------------

//

EXPORT_C MRadioEngineLogger* MRadioEngineLogger::Logger()

    {

    return CRadioEngineTls::Logger();

    }

#ifdef LOGGING_ENABLED

#include <bautils.h>

// Indentation

_LIT( KLogSpace,    "                                " ); // 32 empty spaces

const TInt KMaxIndent = 32;

/**

 * Timestamp formatter string

 */

_LIT8( KTimestampFormat, "%02d.%02d.%4d %02d:%02d:%02d.%05d" );

/**

 * Timestamp separator string

 */

_LIT8( KTimestampSeparator, " " );

// Memory card path. Has to contain directory ( \\) or BaflUtils::PathExists fails

_LIT( KMemoryCard, "E:\\" );

_LIT( KLogEnter,     "\\ %S" );

_LIT( KLogExit,      "/ %S" );

_LIT8( KLogLine,     "| " );

_LIT( KLogLeave,     "#+ %S: LEAVE!" );

_LIT( KLogExitRet,   "/ %S, Returning " );

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

_LIT8( KHexFormat, "ptr: 0x%X" );

// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------

//

// ---------------------------------------------------------------------------

//

CRadioEngineLogger* CRadioEngineLogger::NewL( RFs& aFs )

    {

    CRadioEngineLogger* self = new (ELeave) CRadioEngineLogger( aFs );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// ---------------------------------------------------------------------------

//

// ---------------------------------------------------------------------------

//

CRadioEngineLogger::CRadioEngineLogger( RFs& aFs )

    : iFs( aFs )

    {

    }

// ---------------------------------------------------------------------------

//

// ---------------------------------------------------------------------------

//

void CRadioEngineLogger::ConstructL()

    {

    if ( KLogFile().FindF( KMemoryCard ) == 0 )

        {

        TBool readOnly = EFalse;

        // Returns KErrPathNotFound if memory card is not present

        TInt err = BaflUtils::DiskIsReadOnly( iFs, KMemoryCard, readOnly );

        if ( err || readOnly )

            {

            // Log file path points to the memory card and the card is not

            // present or is read only => change the drive to C:

            TFileName fileName( _L( "C:" ) );

            TParsePtrC parse( KLogFile );

            fileName.Append( parse.Path() );

            fileName.Append( parse.NameAndExt() );

            iFileName = fileName.AllocL();

            }

        }

    if ( !iFileName )

        {

        iFileName = KLogFile().AllocL();

        }

    BaflUtils::EnsurePathExistsL( iFs, *iFileName );

    User::LeaveIfError( Dll::SetTls( this ) );

    }

// ---------------------------------------------------------------------------

//

// ---------------------------------------------------------------------------

//

CRadioEngineLogger::~CRadioEngineLogger()

    {

    iFile.Close();

    delete iFileName;

    }

// ---------------------------------------------------------------------------

// Clear the log by deleting the logfile.

// ---------------------------------------------------------------------------

//

MRadioEngineLogger& CRadioEngineLogger::ClearLog()

    {

    if ( BaflUtils::FileExists( iFs, *iFileName ) )

        {

        // Returned error code ignored intentionally because there is no way

        // to report an error

        BaflUtils::DeleteFile( iFs, *iFileName );

        }

    return *this;

    }

// ---------------------------------------------------------------------------

// Adds a 8-bit string to log line

// ---------------------------------------------------------------------------

//

MRadioEngineLogger& CRadioEngineLogger::Add( const TDesC8& aMsg )

    {

    AddDesC<TPtrC8, TDesC8>( aMsg );

    return *this;

    }

// ---------------------------------------------------------------------------

// Adds a 16-bit string to log line

// ---------------------------------------------------------------------------

//

MRadioEngineLogger& CRadioEngineLogger::Add( const TDesC& aMsg )

    {

    // Note! No character conversion is performed while going from 16-bit

    // descriptor to 8-bit descriptor. This is considered acceptable in a

    // debugging utility

    AddDesC<TPtrC, TDesC>( aMsg );

    return *this;

    }

// ---------------------------------------------------------------------------

// Adds a TInt to log line

// ---------------------------------------------------------------------------

//

MRadioEngineLogger& CRadioEngineLogger::Add( TInt aInt )

    {

    TBuf8<20> buf8;

    buf8.Num( aInt );

    Add( buf8 );

    return *this;

    }

// ---------------------------------------------------------------------------

// Adds a TReal to log line

// ---------------------------------------------------------------------------

//

MRadioEngineLogger& CRadioEngineLogger::Add( const TReal& aReal )

    {

    TBuf8<20> buf8;

    buf8.Format( _L8( "%f" ), aReal );

    Add( buf8 );

    return *this;

    }

// ---------------------------------------------------------------------------

// Adds a c-style string to log line

// ---------------------------------------------------------------------------

//

MRadioEngineLogger& CRadioEngineLogger::Add( const char* aText )

    {

    Add( TPtrC8( reinterpret_cast<const TText8*>( aText ) ) );

    return *this;

    }

// ---------------------------------------------------------------------------

// Adds a pointer value to log line

// ---------------------------------------------------------------------------

//

MRadioEngineLogger& CRadioEngineLogger::Add( const TAny* aPtr )

    {

    TBuf8<20> buf8;

    buf8.Format( KHexFormat, aPtr );

    Add( buf8 );

    return *this;

    }

// ---------------------------------------------------------------------------

// Adds a timestamp of current time to log line

// ---------------------------------------------------------------------------

//

MRadioEngineLogger& CRadioEngineLogger::Add( const TTime& aTime )

    {

    TTimestamp timestamp;

    ParseTimestamp( aTime, timestamp );

    Add( timestamp );

    return *this;

    }

// ---------------------------------------------------------------------------

// Adds a timestamp of current time to log line

// ---------------------------------------------------------------------------

//

MRadioEngineLogger& CRadioEngineLogger::AddTimestamp()

    {

    TTime now;

    now.HomeTime();

    return Add( now );

    }

// ---------------------------------------------------------------------------

// Adds a formatted string to log line

// ---------------------------------------------------------------------------

//

MRadioEngineLogger& CRadioEngineLogger::AddFormat( TRefByValue<const TDesC> aFmt, ... )

    {

    VA_LIST list;

    VA_START( list, aFmt );

    TBuf<KLogBufferLength> buf16;

    // Calls Overflow() if it doesn't fit

    buf16.AppendFormatList( aFmt, list, this );

    VA_END( list );

    Add( buf16 );

    return *this;

    }

// ---------------------------------------------------------------------------

// Adds the line indentation with line prefix to log line

// ---------------------------------------------------------------------------

//

MRadioEngineLogger& CRadioEngineLogger::AddIndent( const TDesC& aMarker )

    {

    Add( aMarker );

    Add( KLogSpace().Mid( 0, iIndent ) );

    Add( KLogLine() );

    return *this;

    }

// ---------------------------------------------------------------------------

// Adds the line indentation to log line

// ---------------------------------------------------------------------------

//

MRadioEngineLogger& CRadioEngineLogger::AddIndentClear( const TDesC& aMarker )

    {

    Add( aMarker );

    Add( KLogSpace().Mid( 0, iIndent ) );

    return *this;

    }

// ---------------------------------------------------------------------------

// From TDes16Overflow

// Handles the overflow from AppendFormatList()

// ---------------------------------------------------------------------------

//

void CRadioEngineLogger::Overflow( TDes16& /*aDes*/ )

    {

    // aDes contains the part that did fit in the descriptor, but the part that

    // didn't is lost. Modifying the descriptor here would modify it in AddFormat(),

    // but since it gets logged there we only need to add a message about the overflow.

    Add( _L( "FORMAT OVERFLOW! " ) );

    }

// ---------------------------------------------------------------------------

// Increment indentation

// ---------------------------------------------------------------------------

//

MRadioEngineLogger& CRadioEngineLogger::IncIndent()

    {

    if ( ++iIndent > KMaxIndent )

        {

        iIndent = KMaxIndent;

        }

    return *this;

    }

// ---------------------------------------------------------------------------

// Decrement indentation

// ---------------------------------------------------------------------------

//

MRadioEngineLogger& CRadioEngineLogger::DecIndent()

    {

    if ( --iIndent < 0 )

        {

        iIndent = 0;

        }

    return *this;

    }

// ---------------------------------------------------------------------------

// Commits the log line to file and RDebug and resets internal buffer

// ---------------------------------------------------------------------------

//

MRadioEngineLogger& CRadioEngineLogger::Commit( TBool aNewLine )

    {

    // Write log buffer to RDebug

    RDebug::RawPrint( iBuf8 );

    // Write log buffer to file

    TInt err = iFile.Open( iFs, *iFileName, EFileWrite );

    if ( err )

        {

        err = iFile.Create( iFs, *iFileName, EFileWrite );

        }

    if ( !err )

        {

        TInt unused = 0;

        if ( iFile.Seek( ESeekEnd, unused ) == KErrNone )

            {

            if ( !iTimeStampWritten )

                {

                // First print a timestamp to log

                TTimestamp timestamp;

                TTime now;

                now.HomeTime();

                ParseTimestamp( now, timestamp );

                iFile.Write( timestamp );

                iFile.Write( KTimestampSeparator );

                iTimeStampWritten = ETrue;

                }

            iFile.Write( iBuf8 );

            if ( aNewLine )

                {

                iFile.Write( KNewLine );

                iTimeStampWritten = EFalse;

                }

            }

        iFile.Close();

        }

    iBuf8.Zero();

    return *this;

    }

// ---------------------------------------------------------------------------

// Returns the amount of characters that still fit in the buffer

// ---------------------------------------------------------------------------

//

TInt CRadioEngineLogger::Available() const

    {

    return iBuf8.MaxLength() - iBuf8.Length();

    }

// ---------------------------------------------------------------------------

// Templated function to add either 8-bit or 16-bit descriptor to buffer

// ---------------------------------------------------------------------------

//

template<class PTR, class DESC>

void CRadioEngineLogger::AddDesC( const DESC& aDesc )

    {

    PTR ptr( aDesc );

    while ( ptr.Length() > Available() )

        {

        PTR writePtr = ptr.Left( Available() );

        iBuf8.Append( writePtr );

        ptr.Set( ptr.Mid( writePtr.Length() ) );

        Commit( EFalse );

        }

    iBuf8.Append( ptr );

    }

// ---------------------------------------------------------------------------

// Parses the timestamp from the given TTime

// ---------------------------------------------------------------------------

//

void CRadioEngineLogger::ParseTimestamp( const TTime& aTime, TTimestamp& aTimestamp )

    {

    TDateTime dateTime = aTime.DateTime();

    aTimestamp.Zero();

    aTimestamp.Format( KTimestampFormat, dateTime.Day() + 1,

                                         dateTime.Month() + 1,

                                         dateTime.Year(),

                                         dateTime.Hour(),

                                         dateTime.Minute(),

                                         dateTime.Second(),

                                         dateTime.MicroSecond() );

    }

// ---------------------------------------------------------------------------

// Constructor. Log method entry

// ---------------------------------------------------------------------------

//

EXPORT_C TRadioMethodLogger::TRadioMethodLogger( const TText* aFunc,

                                                 const TText* aRetFormat )

    : iFunc( aFunc )

    , iRetFormat( aRetFormat )

    {

    MRadioEngineLogger* logger = MRadioEngineLogger::Logger();

    logger->AddIndentClear( KMarkerEngine ).AddFormat( KLogEnter, &iFunc ).Commit();

    logger->IncIndent();

    }

// ---------------------------------------------------------------------------

// Destructor. Log method exit

// ---------------------------------------------------------------------------

//

EXPORT_C TRadioMethodLogger::~TRadioMethodLogger()

    {

    MRadioEngineLogger::Logger()->DecIndent();

    if ( std::uncaught_exception() ) // Leave is an exception

        {

        // The function exited with a leave

        MRadioEngineLogger::Logger()->AddIndentClear( KMarkerEngine ).AddFormat( KLogLeave, &iFunc ).Commit();

        }

    else

        {

        // The function exited normally

        if ( iRetFormat.Length() == 0 )

            {

            MRadioEngineLogger::Logger()->AddIndentClear( KMarkerEngine ).AddFormat( KLogExit, &iFunc ).Commit();

            }

        else

            {

            TBuf<100> format( KLogExitRet );

            format.Append( iRetFormat );

            #if defined( __WINS__ )

                TInt32 retVal = 0;

                _asm( mov retVal, ebx );

                MRadioEngineLogger::Logger()->AddIndentClear( KMarkerEngine ).AddFormat( format, &iFunc, retVal ).Commit();

            #else

                MRadioEngineLogger::Logger()->AddIndentClear( KMarkerEngine ).AddFormat( KLogExit, &iFunc ).Commit();

            #endif

            }

        }

    }

#else // #ifdef LOGGING_ENABLED

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

// Dummy function definitions to keep the exports unchanged when logging is turned off

// These can not be used.

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

EXPORT_C TRadioMethodLogger::TRadioMethodLogger( const TText*, const TText* ) {}

EXPORT_C TRadioMethodLogger::~TRadioMethodLogger() {}

#endif // #ifdef LOGGING_ENABLED