/*

* Copyright (c) 2004 - 2005 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:  Video telephony logger

*

*/

#pragma CTC SKIP

// INCLUDE FILES

#include    "cvtlogger.h"

// LOCAL CONSTANTS

_LIT( KVtEngLogConfig, "c:\\Logs\\VT\\VTLOGCONF.txt" );

_LIT( KVtEngLogFolder, "c:\\Logs\\VT" );

_LIT( KVtEngLogFolderLogger, "VT" );

_LIT( KVtEngLogPrefix, "VT: " );

_LIT( KVtEngLogExtension, ".txt" );

_LIT( KVtLoggerEnterFunc, "<" );

_LIT( KVtLoggerExitFunc, ">" );

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

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

// CVtLogger::CVtLogger

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CVtLogger::CVtLogger() : CActive( CActive::EPriorityStandard - 1 ),

    iLogLevel( ELogLogEverything )

    {

    }

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

// CVtLogger::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CVtLogger::ConstructL( )

    {

    User::LeaveIfError( iFs.Connect() );

    TFindFile find( iFs );

    TUint logLevel( 0 );

    TInt ret = iFs.Att(KVtEngLogFolder, logLevel );

    if ( ret == KErrNone )

        {

        if ( find.FindByPath( KVtEngLogConfig, NULL ) == KErrNone )

            {

            CActiveScheduler::Add( this );

            ReadCongigFile();

            }

        if ( iLogLevel & ELogToFile )

            {

            RThread thread;

            iFileName.Copy( thread.Name() );

            iFileName.Append( KVtEngLogExtension );

            }

        }

    Dll::SetTls( this );

    }

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

// CVtLogger::NewL

// Two-phased constructor.

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

//

CVtLogger* CVtLogger::NewL( )

    {

    CVtLogger* self = new( ELeave ) CVtLogger;

    CleanupStack::PushL( self );

    self->ConstructL( );

    CleanupStack::Pop();

    return self;

    }

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

// CVtLogger::~CVtLogger

// Destructor

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

//

CVtLogger::~CVtLogger()

    {

    Cancel();

    iFs.Close();

    Dll::SetTls( NULL );

    }

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

// CVtLogger::Print

// Writes to log.

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

//

void CVtLogger::Print( TDesC& aDes )

    {

    if ( iLogLevel & ELogTime && !(iLogLevel & ELogToFile) )

        {

        TTime time;

        time.HomeTime();

        const TDateTime dt= time.DateTime();

        iTempBuf.Zero();

        iTempBuf.AppendNum( dt.Minute() );

        iTempBuf.Append(':');

        iTempBuf.AppendNum( dt.Second() );

        iTempBuf.Append(':');

        iTempBuf.AppendNum( dt.MicroSecond() );

        iTempBuf.Append(' ');

        const TInt currentLength( iTempBuf.Length() );

        iTempBuf.Append( aDes.Left( Min( iTempBuf.MaxLength() - currentLength, aDes.Length() ) ) );

        RDebug::Print( iTempBuf );

        }

    else

        {

        if ( iLogLevel & ELogToFile )

            {

            RFileLogger::Write(

                KVtEngLogFolderLogger,

                iFileName,

                EFileLoggingModeAppend,

                aDes );

            }

        else

            {

            RDebug::Print( aDes );

            }

        }

    }

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

// CVtLogger::Print

// Writes to log.

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

//

EXPORT_C void CVtLogger::Print(

    TInt aLevel,

    TPtrC aBuffer )

    {

    CVtLogger* logger = CVtLogger::Logger();

    if ( logger && logger->CheckLevels( aLevel ) )

        {

        logger->iBuffer.Copy( KVtEngLogPrefix );

        logger->iBuffer.Append( aBuffer);

        logger->Print( logger->iBuffer );

        }

    }

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

// CVtLogger::Print

// Writes to log.

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

//

EXPORT_C void CVtLogger::Print(

    TInt aLevel,

    TPtrC aBuffer,

    TInt aValue )

    {

    CVtLogger* logger = CVtLogger::Logger();

    if ( logger && logger->CheckLevels( aLevel ) )

        {

        logger->iBuffer.Zero();

        logger->iBuffer.AppendNum( aValue );

        logger->iBuffer.Format( aBuffer, aValue );

        logger->iBuffer.Insert( 0, KVtEngLogPrefix );

        logger->Print( logger->iBuffer );

        }

    }

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

// CVtLogger::Print

// Writes to log.

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

//

EXPORT_C void CVtLogger::Print(

    TInt aLevel,

    TPtrC aBuffer,

    TInt aValue1,

    TInt aValue2 )

    {

    CVtLogger* logger = CVtLogger::Logger();

    if ( logger && logger->CheckLevels( aLevel ) )

        {

        logger->iBuffer.Format( aBuffer, aValue1, aValue2 );

        logger->iBuffer.Insert( 0, KVtEngLogPrefix );

        logger->Print( logger->iBuffer );

        }

    }

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

// CVtLogger::Print

// Writes to log.

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

//

EXPORT_C void CVtLogger::Print(

            TInt aLevel,

            const TBool aEntry,

            TPtrC aBuffer,

            TInt aRetVal )

    {

    CVtLogger* logger = CVtLogger::Logger();

    if ( logger && logger->CheckLevels( aLevel ) )

        {

        logger->iBuffer.Copy( KVtEngLogPrefix );

        if ( aEntry )

            {

            logger->iBuffer.Append( aBuffer );

            logger->iBuffer.Append( KVtLoggerEnterFunc );

            }

        else

            {

            if ( aRetVal != KVtDebugReturnValNotApplicable )

                {

                logger->iTempBuf.Format( aBuffer, aRetVal );

                logger->iBuffer.Append( logger->iTempBuf );

                }

            else

                {

                logger->iBuffer.Append( aBuffer );

                }

            logger->iBuffer.Append( KVtLoggerExitFunc );

            }

        logger->Print( logger->iBuffer );

        }

    }

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

// CVtLogger::Logger

// Returns logger.

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

//

CVtLogger* CVtLogger::Logger()

    {

    TAny* tls = Dll::Tls();

    if ( tls )

        {

        return reinterpret_cast<CVtLogger*>( tls );

        }

    return NULL;

    }

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

// CVtLogger::Initialize

// Initialize logger.

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

//

EXPORT_C void CVtLogger::Initialize()

    {

    CVtLogger* logger = NULL;

    if ( Dll::Tls() == NULL )

        {

        TRAPD( err, logger = CVtLogger::NewL() );

        if ( err == KErrNone )

            {

            Dll::SetTls( logger );

            }

        }

    else

        {

        logger = CVtLogger::Logger();

        }

    if ( logger )

        {

        (logger->iAccessCount)++;

        }

    }

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

// CVtLogger::Uninitialize

// Uninitialize logger.

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

//

EXPORT_C void CVtLogger::Uninitialize()

    {

    TAny* tls = Dll::Tls();

    if ( tls )

        {

        CVtLogger* logger = CVtLogger::Logger();

        if( logger )

            {

            TInt count( --(logger->iAccessCount) );

            if ( !count )

                {

                delete reinterpret_cast<CVtLogger*>( tls );

                Dll::SetTls( NULL );

                }

            }

        }

    }

void CVtLogger::ReadCongigFile()

    {

#ifdef _DEBUG

    RDebug::Print(_L(" VT: ReadConfigFile" ) );

#endif

    RFile config;

    if ( config.Open( iFs, KVtEngLogConfig, EFileShareAny ) == KErrNone )

        {

        TBuf8<16> buf;

        if ( config.Read( buf ) == KErrNone )

            {

            TLex8 lex( buf );

            TUint logLevel( 0 );

            if ( lex.Val( logLevel, EHex ) == KErrNone )

                {

                iLogLevel = logLevel;

                }

            }

        config.Close();

        }

    iFs.NotifyChange( ENotifyEntry, iStatus, KVtEngLogConfig() );

    SetActive();

    }

void CVtLogger::RunL()

    {

    if ( iStatus == KErrNone )

        {

        ReadCongigFile();

        }

    }

void CVtLogger::DoCancel()

    {

    iFs.NotifyChangeCancel();

    }

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

// CVtLogger::Flags

// Returns flags.

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

//

EXPORT_C TInt CVtLogger::Flags()

    {

    CVtLogger* logger = CVtLogger::Logger();

    if ( logger )

        {

        return logger->iLogLevel;

        }

    return KErrGeneral;

    }

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

// CVtLogger::CheckLevels

// Check debug level.

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

//

TBool CVtLogger::CheckLevels( TInt aLevels ) const

    {

    if ( aLevels & iLogLevel )

        {

        return ETrue;

        }

    return EFalse;

    }

#pragma CTC ENDSKIP

//  End of File