/*

* Copyright (c) 2003-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:  This file contains the implementation of CPELogHandling class 

*                member functions.

*

*/

//  INCLUDE FILES

#include <spsettings.h>

#include <spproperty.h>

#include <telloggingextension.h>

#include <ecom.h> 

#include "cpeloghandling.h"

#include "cpelogevent.h"

#include "cpeloghandlingcommand.h"

#include "cpelogexternaldata.h"

#include <talogger.h>

#include <logcli.h>

#include <pepanic.pan>

#include <mpephonemodelinternal.h>

#include <mpedatastore.h>

#include "cpeloginfo.h"

#include "cpelogextensionwrapper.h"

// EXTERNAL DATA STRUCTURES

// None

// EXTERNAL FUNCTION PROTOTYPES  

/// None

// CONSTANTS

// None

// MACROS

// None

// LOCAL CONSTANTS AND MACROS

// None

// MODULE DATA STRUCTURES

// None

// LOCAL FUNCTION PROTOTYPES

// None

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

// CPELogHandling::NewL

// Two-phased constructor.

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

//

MPELogHandling* CPELogHandling::NewL

        ( 

        MPEPhoneModelInternal& aModel,        // Owner of the object

        RFs& aFsSession                       // Handle to a file server session

        )  

    {

    TEFLOGSTRING(KTAOBJECT, "LOG CPELogHandling::NewL start.");

    CPELogHandling* self = 

        new ( ELeave ) CPELogHandling( aModel, aFsSession );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    TEFLOGSTRING(KTAOBJECT, "LOG CPELogHandling::NewL complete.");

    return self;

    }

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

// CPELogHandling::~CPELogHandling

// Destructor.

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

//

/*****************************************************

*    Series 60 Customer / LOGENG

*    Series 60  LOGENG API

*****************************************************/

EXPORT_C CPELogHandling::~CPELogHandling()

    {

    TEFLOGSTRING( KTAOBJECT, "LOG CPELogHandling::~CPELogHandling" );

    delete iLogExternalData;

    iFreeLogEventArray.ResetAndDestroy();

    iActiveLogEventArray.ResetAndDestroy();

    // All created CPELogEvent objects must be either in Free or Active array

    // That is, it would be error to destroy objects in queued array.

    iQueuedLogEventArray.Reset();

    iActiveCallIds.Close();

    delete iLogHandlingCommand;

    delete iLogClient;

    iPlugins.ResetAndDestroy();

    REComSession::FinalClose();

    }

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

// CPELogHandling::CPELogHandling

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

// might leave.

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

//

CPELogHandling::CPELogHandling

        ( 

        MPEPhoneModelInternal& aModel,

        RFs& aFsSession        

        ) : iModel( aModel ),

            iDataStore( *( aModel.DataStore( ) ) ),

            iFsSession( aFsSession ),

            iLogEventUnderProcessing( NULL )

    {

    TEFLOGSTRING( KTAOBJECT, "LOG CPELogHandling::CPELogHandling" );

    }

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

// CPELogHandling::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

/*****************************************************

*    Series 60 Customer / LOGENG

*    Series 60  LOGENG API

*****************************************************/

void CPELogHandling::ConstructL()

    {

    TEFLOGSTRING( KTAOBJECT, "LOG CPELogHandling::ConstructL" );

    // Create new instace of the Log Client

    iLogClient = CLogClient::NewL( iFsSession ); 

    // Enumeration for incoming call, get from database 

    User::LeaveIfError( iLogClient->GetString( iLogStringIn, R_LOG_DIR_IN ) ); 

    // Enumeration for outgoing call, get from database 

    User::LeaveIfError( iLogClient->GetString( iLogStringOut, R_LOG_DIR_OUT ) );   

    // Enumeration for missed call, get from database

    User::LeaveIfError( iLogClient->GetString( iLogStringMissed, R_LOG_DIR_MISSED ) );   

    // Enumeration for delivery call, get from database  

    User::LeaveIfError( iLogClient->GetString( iLogStringDelivery, R_LOG_DEL_NONE ) ); 

    // Enumeration for incoming auxiliary line, get from database 

    User::LeaveIfError( iLogClient->GetString( iLogStringInAlt, R_LOG_DIR_IN_ALT ) );   

    // Enumeration for outgoing auxiliary line, get from database  

    User::LeaveIfError( iLogClient->GetString( iLogStringOutAlt, R_LOG_DIR_OUT_ALT ) );

    // Enumeration for unknown name, get from database  

    User::LeaveIfError( iLogClient->GetString( iLogStringUnknown, R_LOG_REMOTE_UNKNOWN ) );

    iLogHandlingCommand = new (ELeave) CPELogHandlingCommand( *this, *iLogClient );

    // Reserve some log events here. We delete these log event objects only on the destructor.

    for( TInt entryIndex = 0; entryIndex < KPEMaximumNumberOfLogEvents; entryIndex++ )

        {

        CPELogEvent* logEvent = CPELogEvent::NewL( *this, *iLogHandlingCommand );

        CleanupStack::PushL( logEvent );

        iFreeLogEventArray.AppendL( logEvent );

        CleanupStack::Pop( logEvent );

        }

    // Compress free log event array as it would never contain more objects than create here

    iFreeLogEventArray.Compress( );

    iLogExternalData = CPELogExternalData::NewL( *this );

    }

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

// CPELogHandling::SaveCallEntry

// Creates log info and initiates saving call log info by calling SaveCallInfoL.

// Do log handling cleanup in case of a leave.

// (other items were commented in a header).

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

//

EXPORT_C TInt CPELogHandling::SaveCallEntry

        ( 

        const TInt aCallId

        )

    {

    TInt errorCode( KErrArgument );

    if ( CallIdCheck::IsVoice( aCallId ) || 

         CallIdCheck::IsVideo( aCallId )

       ) 

        {

        CPELogInfo* logInfo( NULL );

        TRAP( errorCode, logInfo = CPELogInfo::NewL(); );

        if ( logInfo )

            {

            // continue gathering log data

            // set phonenumber and/or voip address

            SetRemoteContact( aCallId, *logInfo );

            logInfo->SetEventData( aCallId, iDataStore ); 

            TRAP_IGNORE( 

                // Contact link can be big, not critical for basic functionality.

                if ( &iDataStore.ContactId( aCallId ) )

                    {

                    // Pack and add link

                    HBufC8* buf( iDataStore.ContactId( aCallId ).PackLC() );

                    TEFLOGSTRING( KTAINT, "Contact id packed" );

                    logInfo->SetContactLink( buf ); 

                    CleanupStack::Pop( buf );

                    }

                // default logging strategy is used if error happens while using extension

                UpdateLogInfoWithExtensionDataL( aCallId, *logInfo ) );

            TRAP( errorCode, SaveCallInfoL( *logInfo ) );

            delete logInfo;

            }

        if( errorCode != KErrNone )

            {

            DoCleanup();

            }

        }

    return errorCode;

    }

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

// CPELogHandling::SendMessage

// Method reroutes messages from other modules to the CPEPho-object

// Note that it does not use base class SendMessage.

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

//

void CPELogHandling::SendMessage

        ( 

        const MEngineMonitor::TPEMessagesFromPhoneEngine aMessage, // The message id number of the message.

        TInt aErrorCode

        )

    {

    if ( aMessage == MEngineMonitor::EPEMessageLogEventSaved )

        {

        TEFLOGSTRING( KTAINT, "LOG CPELogHandling::SendMessage(), Log event saved" );                        

        if (aErrorCode == KErrNone )

            {

            // flag event entry as added; next event is to be just entry update.

            iLogEventUnderProcessing->SetAdded( );

            }

        if ( iLogEventUnderProcessing->IsCompleted( ) )

            {

            TEFLOGSTRING( KTAINT, "LOG CPELogHandling::SendMessage(), Log entry completed" );                       

            DeleteArrayEntry( iLogEventUnderProcessing );

            }

        // Indicate that no processing of log event is in progress

        iLogEventUnderProcessing = NULL;            

        if ( iQueuedLogEventArray.Count( ) > 0 )

            {

            TEFLOGSTRING( KTAINT, "LOG CPELogHandling::SendMessage(), Executing queued request" );

            CPELogEvent* logEvent = iQueuedLogEventArray[0];

            iQueuedLogEventArray.Remove( 0 );

            iLogEventUnderProcessing = logEvent;

            TRAPD( error, logEvent->SaveL( ) );

            if ( error != KErrNone )

                {

                DoCleanup();

                }

            }

        }

    else

        {

        TEFLOGSTRING2( KTAINT, "LOG CPELogHandling::SendMessage(), Message %d not supported", aMessage );

        }   

    }

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

// CPELogHandling::LogStringIn

// Get log string.

// (other items were commented in a header).

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

//

TLogString& CPELogHandling::LogStringIn

        (

        // None

        )

    {

    return iLogStringIn;

    }

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

// CPELogHandling::LogStringOut

// Get log string.

// (other items were commented in a header).

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

//

TLogString& CPELogHandling::LogStringOut

        (

        // None

        )

    {

    return iLogStringOut;

    }

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

// CPELogHandling::LogStringMissed

// Get log string.

// (other items were commented in a header).

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

//

TLogString& CPELogHandling::LogStringMissed

        (

        // None

        )

    {

    return iLogStringMissed;

    }

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

// CPELogHandling::LogStringIn

// Get log string.

// (other items were commented in a header).

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

//

TLogString& CPELogHandling::LogStringDelivery

        (

        // None

        )

    {

    return iLogStringDelivery;

    }        

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

// CPELogHandling::LogStringIn

// Get log string.

// (other items were commented in a header).

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

//

TLogString& CPELogHandling::LogStringInAlt

        (

        // None

        )

    {

    return iLogStringInAlt;

    }

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

// CPELogHandling::LogStringOutAlt

// Get log string.

// (other items were commented in a header).

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

//

TLogString& CPELogHandling::LogStringOutAlt

        (

        // None

        )

    {

    return iLogStringOutAlt;

    }

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

// CPELogHandling::LogStringUnknown

// Get log string.

// (other items were commented in a header).

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

//

TLogString& CPELogHandling::LogStringUnknown

        (

        // None

        )

    {

    return iLogStringUnknown;

    }

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

// CPELogHandling::SetRemoteContact

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

//

void CPELogHandling::SetRemoteContact( TInt aCallId, CPELogInfo& aLogInfo )

    {

    aLogInfo.SetVoipAddress( KNullDesC() );

    if ( iDataStore.CallDirection( aCallId ) 

            == RMobileCall::EMobileOriginated )

        {

        TEFLOGSTRING2(KTAINT, 

            "LOG CPELogHandling::CreateLogInfo, WholeOutgoingPhoneNumber, aCallId: %d"

            , aCallId )

        aLogInfo.SetPhoneNumber( iDataStore.WholeOutgoingPhoneNumber( aCallId ) );

        }

    else

        {

        aLogInfo.SetPhoneNumber( iDataStore.RemotePhoneNumber( aCallId ) );

        }

    if ( EPECallTypeVoIP == iDataStore.CallType( aCallId ) )

        {

        // voip address field must be used for voip calls

        aLogInfo.SetVoipAddress( aLogInfo.PhoneNumber() );

        aLogInfo.SetPhoneNumber( KNullDesC() );

        }

    }

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

// CPELogHandling::SaveCallInfoL

// Update log external data.

// Call SaveEventL if event should be saved to log db.

// (other items were commented in a header).

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

//

void CPELogHandling::SaveCallInfoL

        ( 

        const CPELogInfo& aLogInfo // Call information

        )

    {

    TEFLOGSTRING3( KTAINT, "LOG CPELogHandling::SaveCallInfoL(), [CallID: %d], [CallState: %d]", aLogInfo.CallId(), aLogInfo.CallState() );

    if ( EPEStateConnected == aLogInfo.CallState() )

        {

        // Insert the call ID to the active call array when the call state is connected.

        TInt err = iActiveCallIds.InsertInOrder( aLogInfo.CallId() );

        if ( err != KErrAlreadyExists )

            {

            User::LeaveIfError( err );

            }

        // Only for the first call set the first call start time

        if ( iActiveCallIds.Count() == 1 )

            {

            // For Last active call timer. See end part of UpdateLastCallTimer.

            iLogExternalData->SetFirstCallStartTime( aLogInfo.CallStartTime() );

            }

        // We have already store the start time to log database on dialling/ringing state,

        // but this is the real start time of call.

        TBuf<KPEESDWFormattedTimeLength> formattedTime;

        formattedTime.Zero();

        aLogInfo.CallStartTime().FormatL( formattedTime, KPEESDWTimeFormat ); 

        TEFLOGSTRING2( KTAINT, "LOG CPELogHandling::SaveCallInfoL() Connected state iCallStartTime > formattedTime: %S", &formattedTime );

        }

    else

        {

        // logsEntry handling only on Dialling/Ringing and Idle states.

        if ( EPEStateIdle == aLogInfo.CallState() )

            {          

            iLogExternalData->UpdateCallTimers( aLogInfo );

            if ( aLogInfo.MissedCall() )  

                {

                iLogExternalData->IncreaseMissedCallValue( aLogInfo.CallId() );

                }

            TInt index = iActiveCallIds.FindInOrder( aLogInfo.CallId() );

            if ( index >= 0 )

                {

                // When a call is disconnected, its ID is removed from the active call array.

                iActiveCallIds.Remove( index );

                iLogExternalData->UpdateLastCallTimerByLine( aLogInfo );

                if ( iActiveCallIds.Count() == 0 )

                    {

                    TInt duration = iLogExternalData->UpdateLastCallTimer( aLogInfo );

                    iModel.DataStore()->SetCallDuration( duration );

                    }

                }

            }

        if ( aLogInfo.LoggingEnabled() ) 

            {

            // We log all voice calls and the following data/fax calls to Log database

            // MO external Data calls,

            // MO external Fax calls,

            // MT external Data calls

            // MT external Fax calls,

            // MT internal Data calls,

            // We don't log the following data/fax calls to Log database

            // MO internal Data calls

            // MO internal Fax calls,

            // MT internal Fax calls, 

            // these are logged by CSD agent.

            // But we have to update timers for these calls.            

            SaveEventL( aLogInfo );

            }

        }

    }

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

// CPELogHandling::SaveEventL

// Update log database entry for an event. Manages event queueing.

// (other items were commented in a header).

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

//

void CPELogHandling::SaveEventL

        ( 

        const CPELogInfo& aLogInfo  // Log information

        ) 

    {

    TInt index;

    CPELogEvent* logEvent;

    index = FindEventIndexById( aLogInfo.CallId() ); 

    if ( index == KErrNotFound ) 

        {

        // a log event object can't be reused;  

        TEFLOGSTRING2( KTAINT, "LOG CPELogHandling::SaveEventL(), [CallID: %d]",aLogInfo.CallId() );

        TEFLOGSTRING2( KTAINT, "LOG CPELogHandling::SaveEventL(), [CallDirection: %d]", aLogInfo.CallDirection() );

        if ( iFreeLogEventArray.Count() > 0 )

            {

            // reuse an already created object from the array of the freed log event objects

            logEvent = iFreeLogEventArray[ 0 ];

            iFreeLogEventArray.Remove( 0 );

            }

        else 

            {

            // create a new object; none available to be reused

            logEvent = CPELogEvent::NewL( *this, *iLogHandlingCommand );

            }

        CleanupStack::PushL( logEvent );

        iActiveLogEventArray.AppendL( logEvent );

        CleanupStack::Pop( logEvent );            

        }

    else

        {

        // the log event object is already active but not completed. reuse it.

        logEvent = iActiveLogEventArray[ index ];

        }