/*

* Copyright (c) 2007-2007 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 <centralrepository.h>

#include "voipeventlogengine.h"

#include "voipeventlogconstants.h"

#include "voiperrorentry.h"

#include "voipeventloglogger.h" // For logging

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

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

// Constructor

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

//

CVoipEventLogEngine::CVoipEventLogEngine()

    {

    }

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

// Constructor

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

//

void CVoipEventLogEngine::ConstructL()

    {

    VELLOGSTRING( "CVoipEventLogEngine::ConstructL() - IN" );

    iRepository = CRepository::NewL( KCRUidVoIPEventLog );

    TInt err = iSemaphore.OpenGlobal( KVoIPEventLogSemaphore );

    if ( err != KErrNone )

        {

        User::LeaveIfError( iSemaphore.CreateGlobal( KVoIPEventLogSemaphore, 1 ) );

        }

    VELLOGSTRING( "CVoipEventLogEngine::ConstructL() - OUT" );

    }

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

// Constructor

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

//

CVoipEventLogEngine* CVoipEventLogEngine::NewL()

    {

    CVoipEventLogEngine* self = CVoipEventLogEngine::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// Constructor

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

//

CVoipEventLogEngine* CVoipEventLogEngine::NewLC()

    {

    CVoipEventLogEngine* self = new( ELeave ) CVoipEventLogEngine;

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// Destructor

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

//

CVoipEventLogEngine::~CVoipEventLogEngine()

    {

    VELLOGSTRING( "CVoipEventLogEngine::~CVoipEventLogEngine() - IN" );

    delete iRepository;

    iSemaphore.Close();

    VELLOGSTRING( "CVoipEventLogEngine::~CVoipEventLogEngine() - OUT" );

    }

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

// release semaphore, this function is used in custom cleanup

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

//

void CVoipEventLogEngine::ReleaseSemaphore( TAny* aEngine )

    {

    ASSERT ( aEngine );

    CVoipEventLogEngine* engine = static_cast<CVoipEventLogEngine*>( aEngine );

    engine->DoReleaseSemaphore();

    }

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

// release semaphore

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

//

void CVoipEventLogEngine::DoReleaseSemaphore()

    {

    iSemaphore.Signal();

    }

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

// Begins transaction in repository.

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

//

void CVoipEventLogEngine::BeginTransactionLC()

    {

    VELLOGSTRING( "CVoipEventLogEngine::BeginTransaction() - IN" );

    iSemaphore.Wait();

    TCleanupItem cleanup( CVoipEventLogEngine::ReleaseSemaphore, this );

    CleanupStack::PushL( cleanup );

    User::LeaveIfError( iRepository->StartTransaction( CRepository::EReadWriteTransaction ) );

    iRepository->CleanupRollbackTransactionPushL(); // if leave happens, only roll back, no delete

    VELLOGSTRING( "CVoipEventLogEngine::BeginTransaction() - OUT" );

    }

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

// Commits changes in repository.

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

//

void CVoipEventLogEngine::CommitTransactionL()

    {

    VELLOGSTRING(

        "CVoipEventLogEngine::CommitTransactionL() - IN" );

    TUint32 temp;

    User::LeaveIfError( iRepository->CommitTransaction( temp ) );

    iSemaphore.Signal();

    CleanupStack::Pop( 2 ); // semaphore and repository

    VELLOGSTRING( "CVoipEventLogEngine::CommitTransaction() - OUT" );

    }

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

// Generate time stamp with current time

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

//

void CVoipEventLogEngine::GenerateTimeStampL( TDes& aTimeStamp) const

    {

    TTime now;

    now.HomeTime();

    now.FormatL( aTimeStamp, KVoIPTimeStampFormat );

    }

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

// Get latest index number

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

//

TInt CVoipEventLogEngine::GetLatestIndexL()

    {

    TInt latestIndex( 0 );

    User::LeaveIfError( iRepository->Get( KVELLatestErrorIndexKey, latestIndex ) );

    return latestIndex;

    }

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

// Get new index number

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

//

TInt CVoipEventLogEngine::GetNewIndexL()

    {

    TInt latestIndex = GetLatestIndexL();

    TInt maxCount = GetMaxErrorCountL();

    TInt newIndex = latestIndex + 1;

    if( newIndex >= maxCount )

        {

        newIndex = newIndex - maxCount;

        }

    return newIndex;

    }

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

// Get maximum error count

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

//

TInt CVoipEventLogEngine::GetMaxErrorCountL()

    {

    TInt count( 0 );

    User::LeaveIfError( iRepository->Get( KVELMaxErrorCountKey, count ) );

    return count;

    }

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

// Writes an error data to event log

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

//

void CVoipEventLogEngine::WriteErrorL( const CVoipErrorEntry& aErrorEntry )

    {

    if( aErrorEntry.ErrorText().Length() > NCentralRepositoryConstants::KMaxBinaryLength )

        {

        User::Leave( KErrArgument );

        }

    TInt newIndex = GetNewIndexL();

    TBuf<KTimeStampStrLen> timeStamp;

    GenerateTimeStampL( timeStamp );

    // error code

    TUint32 key = newIndex + KSPColumnErrorCode;

    User::LeaveIfError( iRepository->Set( key, aErrorEntry.ErrorCode() ) );

    // error text

    key += KColumnIncrement;

    User::LeaveIfError( iRepository->Set( key, aErrorEntry.ErrorText() ) );

    // time stamp

    key += KColumnIncrement;

    User::LeaveIfError( iRepository->Set( key, timeStamp ) );

    // save newIndex to latest index

    User::LeaveIfError( iRepository->Set( KVELLatestErrorIndexKey, newIndex ) );

    // save new count to cenrep

    TInt count( 0 );

    User::LeaveIfError( iRepository->Get( KVELErrorCountKey, count ) );

    if( count < GetMaxErrorCountL() )

        {

        count++;

        User::LeaveIfError( iRepository->Set( KVELErrorCountKey, count ) );

        }

    }

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

// Reads error count from the log

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

//

void CVoipEventLogEngine::ErrorCountL( TInt& aCount )

    {

    User::LeaveIfError( iRepository->Get( KVELErrorCountKey, aCount ) );

    }

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

// Reset voip errors log history.

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

//

TInt CVoipEventLogEngine::ResetLogHistory()

    {

    TInt retValue = iRepository->Reset();

    return retValue;

    }

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

// Reads an error informaiton from the log

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

//

void CVoipEventLogEngine::ReadErrorL( TInt aIndex, CVoipErrorEntry& aErrorEntry )

    {

    TInt count( 0 );

    ErrorCountL( count );

    if( aIndex > count - 1 )

        {

        User::Leave( KErrNotFound );

        }

    TInt latestIndex = GetLatestIndexL();

    TInt index = latestIndex - aIndex;

    if( index < 0 )

        {

        index += count;

        }

    // error code

    TUint32 key = index + KSPColumnErrorCode;

    TInt errorCode;

    User::LeaveIfError( iRepository->Get( key, errorCode ) );

    aErrorEntry.SetErrorCode( errorCode );

    // error text

    HBufC* errorText = HBufC::NewLC( NCentralRepositoryConstants::KMaxBinaryLength );

    TPtr ptrErrorText = errorText->Des();

    key += KColumnIncrement;

    User::LeaveIfError( iRepository->Get( key, ptrErrorText ) );

    // error timestamp

    HBufC* timeStamp = HBufC::NewLC( KTimeStampStrLen );

    TPtr ptrTimeStamp = timeStamp->Des();

    key += KColumnIncrement;

    User::LeaveIfError( iRepository->Get( key, ptrTimeStamp ) );

    // set new data to aErrorEntry

    User::LeaveIfError( aErrorEntry.SetErrorText( *errorText ) );

    User::LeaveIfError( aErrorEntry.SetTimeStamp( *timeStamp ) );

    CleanupStack::PopAndDestroy( 2, errorText );

    }