/*

* 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:  Data Connection Logger.

*

*/

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <logengdurations.h>

#include <logwraplimits.h>

#include <logengevents.h>

#endif

#include <cdbcols.h>

#include <bldvariant.hrh> // Feature IDs

#include <featmgr.h>

#include <utf.h>

#include <centralrepository.h>

#include "DclPrivateCRKeys.h"

#include "dcl.h"

#include "dclTimer.h"

#include "dcl_log.h"

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

// CEngine::CEngine

// Constructor

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

//

CEngine::CEngine()

        :

        CActive( EPriorityStandard ),

        iLogClient( NULL ),

        iTimerInterval( KTimerInterval )

    {

    CActiveScheduler::Add( this );

    }

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

// CEngine::NewLC

// 1st phase constructor - for stack pointers to object

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

//

CEngine* CEngine::NewLC( )

    {

    CEngine* self = new( ELeave ) CEngine();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CEngine::NewL

// 1st phase constructor - for heap pointers to object

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

//

CEngine* CEngine::NewL( )

    {

    CEngine* self = NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// CEngine::ConstructL

// 2nd phase constructor

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

//

void CEngine::ConstructL()

    {

    LOGENTRFN("CEngine::ConstructL()")

    // Renaming the thread with the real process name helps debugging panics.

    RThread::RenameMe( KDCLName );

    FeatureManager::InitializeLibL();

    iConnectionMonitor.ConnectL();

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

    iLogWrap = CLogWrapper::NewL( iFsEventLog, CActive::EPriorityStandard );

    iLogEventQueue = new( ELeave ) CArrayPtrFlat<CEvent>( KEventStateMaxCount );

    iLogEventQueue->Reset();

    iConnections = new( ELeave ) CArrayPtrFlat<CEvent>( KEventStateMaxCount );

    iConnections->Reset();

    iCurrentLogEvent = CLogEvent::NewL();

    iLogClient = CLogClient::NewL( iFsEventLog );

    // Connect to ETel server

    // The RTelServer::Connect() might not always work with the first trial,

    // because of a coding error related to using semaphores in the method.

    TInt err( KErrNotReady );

    TInt a = 0;

    while( a < KPhoneRetryCount && err != KErrNone )

        {

        if ( a )

            {

            User::After( KPhoneRetryTimeout ); // Don't wait on first try

            }

        err = iTelServer.Connect();

        LOGIT1("Connecting to ETel server <%d>", err)

        a++;

        }

    User::LeaveIfError( err );

    // Try to load phone.tsy

    TBuf<KCommsDbSvrMaxColumnNameLength> tsyName;

    tsyName.Copy( KMmTsyModuleName );

    err = iTelServer.LoadPhoneModule( tsyName );

    if ( err == KErrNone )

        {

        iTSYLoaded = 1;

        // Phone info can be retrieved with value 0 if there is only 1 phone

        RTelServer::TPhoneInfo info;

        User::LeaveIfError( iTelServer.GetPhoneInfo( 0, info ) );

        User::LeaveIfError( iMobilePhone.Open( iTelServer, info.iName ) );

        // Open packet service

        err = iPacketService.Open( iMobilePhone );

        if ( err == KErrNone )

            {

            iPacketServLoaded = 1;

            }

        }

    if ( FeatureManager::FeatureSupported( KFeatureIdLoggerGprs ) )

        {

        LOGIT0("LoggerGprs supported")

        // Get the Attach Mode setting from CommDb and set ETel to use that

        // value. Must not leave if an error occurs.

        TRAPD( leaveCode, SetAttachModeL() );

        LOGIT1("SetAttachModeL() result: <%d>", leaveCode)

        // Get the default APN from CommDb and set ETel to use that APN.

        // Must not leave if an error occurs.

        TRAP( leaveCode, SetAPNL() );

        LOGIT1("SetAPNL() result: <%d>", leaveCode)

        }

    // Adds the event type Wlan. Otherwise the LogClient

    // will not understand this type of event.

    AddEventTypeL();

    // Read ini file settings

    ReadIniFile();

    // Create timer mode AO

    iDclTimerAO = new( ELeave ) CDclTimerAO ( this, iTimerInterval );

    iDclTimerAO->ConstructL();

    // Create saeObserver for updating P&S variables

    iSaeObserver = CSaeObserver::NewL( iConnectionMonitor );

    LOGEXITFN("CEngine::ConstructL()")

    }

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

// CEngine::~CEngine

// Destructor

// Frees reserved resources.

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

//

CEngine::~CEngine()

    {

    LOGENTRFN("CEngine::~CEngine()")

    FeatureManager::UnInitializeLib();

    delete iSaeObserver;

    iSaeObserver = NULL;

    // Disconnect from CM server.

    iConnectionMonitor.Close();

    Cancel();

    // The queue could be not empty if the active object

    // is aborted and destructed.

    if ( iLogEventQueue != 0 )

        {

        iLogEventQueue->ResetAndDestroy();

        }

    if ( iConnections != 0 )

        {

        iConnections->ResetAndDestroy();

        }

    delete iLogWrap;

    iLogWrap = NULL;

    delete iLogEventQueue;

    iLogEventQueue = NULL;

    delete iConnections;

    iConnections = NULL;

    delete iCurrentLogEvent;

    iCurrentLogEvent = NULL;

    delete iLogEventType;

    iLogEventType = NULL;

    delete iLogClient;

    iLogClient = NULL;

    iFsEventLog.Close();

    // Close "global" ETEL objects

    if ( iPacketServLoaded == 1 )

        {

        iPacketService.Close();

        }

    iMobilePhone.Close();

    iTelServer.Close();

    delete iDclTimerAO;

    iDclTimerAO = NULL;

    LOGEXITFN("CEngine::~CEngine()")

    }

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

// CEngine::NotifyL

// Request Connection Monitor server to send notifications of events.

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

//

void CEngine::NotifyL()

    {

    iConnectionMonitor.NotifyEventL( *this );

    }

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

// CEngine::EventL

// Receives notifications of events from Connection Monitor server.

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

//

void CEngine::EventL( const CConnMonEventBase& aConnMonEvent )

    {

    //LOGENTRFN("CEngine::EventL()")

    LOGIT1("-> CEngine::EventL() entered, event type (%d)", aConnMonEvent.EventType())

    TInt err( KErrNone );

    TUint connectionId( 0 );

    // Update P&S variables first

    if ( iSaeObserver )

        {

        iSaeObserver->EventL( aConnMonEvent );

        }

    switch ( aConnMonEvent.EventType() )

        {

        case EConnMonCreateConnection:

            {

            TInt bearer( 0 );

            TRequestStatus status( KErrNotReady );

            const CConnMonCreateConnection* eventCreate;

            eventCreate  = static_cast<const CConnMonCreateConnection*>( &aConnMonEvent );

            connectionId = eventCreate->ConnectionId();

            LOGIT1("*** EConnMonCreateConnection event, id %d ***", connectionId)

            // Get the bearer info from CM server.

            err = KErrNotReady;

            TInt a = 0;

            while( a < KPhoneRetryCount && err != KErrNone )

                {

                // ConnMon might not be able to provide KBearer with the first trial.

                if ( a )

                    {

                    User::After( KPhoneRetryTimeout ); // Don't wait on first try

                    }

                iConnectionMonitor.GetIntAttribute(

                        connectionId,

                        KSubConnectionId,

                        KBearer,

                        bearer,

                        status );

                User::WaitForRequest( status );

                err = status.Int();

                LOGIT2("Got bearer %d from ConnMon <%d>", bearer, err)

                a++;

                }

            if ( err != KErrNone )

                {

                LOGIT1("FAILED to get KBearer from ConnMon <%d>", err)

                break;

                }

            // Check that it is GPRS or WCDMA.

            if ( bearer == EBearerGPRS     ||

                 bearer == EBearerEdgeGPRS ||

                 bearer == EBearerWCDMA )

                {

                LOGIT0("New internal connection")

                // Set the uplink and downlink thresholds for this particular connection.

                TUint threshold( iGPRSThreshold );

                if ( bearer == EBearerWCDMA )

                    {

                    threshold = iWCDMAThreshold;

                    }

                err = iConnectionMonitor.SetUintAttribute(

                        connectionId,

                        KSubConnectionId,

                        KDownlinkDataThreshold,

                        threshold );

                if ( err != KErrNone )

                    {

                    LOGIT1("FAILED to set KDownlinkDataThreshold to ConnMon <%d>", err)

                    }

                err = iConnectionMonitor.SetUintAttribute(

                        connectionId,

                        KSubConnectionId,

                        KUplinkDataThreshold,

                        threshold );

                if ( err != KErrNone )

                    {

                    LOGIT1("FAILED to set KUplinkDataThreshold to ConnMon <%d>", err)

                    }

                TName iapName;

                iapName.FillZ();

                iapName.Zero();

                // Get String Attribute -> KIAPName.

                // Get IAP name from CM server.

                err = KErrNotReady;

                a = 0;

                while( a < KPhoneRetryCount && err != KErrNone )

                    {

                    // ConnMon might not be able to provide KIAPName with the first trial.

                    if ( a )

                        {

                        User::After( KPhoneRetryTimeout ); // Don't wait on first try

                        }

                    iConnectionMonitor.GetStringAttribute(

                            connectionId,

                            KSubConnectionId,

                            KIAPName,

                            iapName,

                            status );

                    User::WaitForRequest( status );

                    err = status.Int();

                    LOG( TBuf<KMaxName+1> iapName2( iapName ); )

                    LOGIT2("Got KIAPName from ConnMon <%s>, <%d>", iapName2.PtrZ(), err)

                    a++;

                    }

                if ( err == KErrNone )

                    {

                    LogDataAddEventL(

                            connectionId,

                            R_LOG_CON_CONNECTED,

                            iapName,

                            R_LOG_DIR_OUT,

                            KNullDesC,

                            KLogPacketDataEventTypeUid );

                    }

                else

                    {

                    LOGIT1("FAILED to get KIAPName from ConnMon <%d>", err)

                    }

                }

            else if ( bearer == EBearerWLAN )

                // Add EBearerExternalWLAN in order to enable DCL to log

                // external WLAN connections, i.e. then the mobile phone

                // functions as a WLAN modem

                {

                LOGIT0("New WLAN connection")

                // Set the uplink and downlink thresholds for this particular connection.

                err = iConnectionMonitor.SetUintAttribute(

                        connectionId,

                        KSubConnectionId,

                        KDownlinkDataThreshold,

                        iWLANThreshold );

                if ( err != KErrNone )

                    {

                    LOGIT1("FAILED to set KDownlinkDataThreshold to ConnMon <%d>", err)

                    }

                // Even if KDownlinkDataThreshold and KUplinkDataThreshold

                // are used here ( 4096 bytes ), the Connection Monitor

                // server actually sets the threshold to 20480 bytes =

                // 20 kilobytes.

                err = iConnectionMonitor.SetUintAttribute(

                        connectionId,

                        KSubConnectionId,

                        KUplinkDataThreshold,

                        iWLANThreshold );

                if ( err != KErrNone )

                    {

                    LOGIT1("FAILED to set KUplinkDataThreshold to ConnMon <%d>", err)

                    }

                TName iapName;

                iapName.FillZ();

                iapName.Zero();

                // Get Uint Attribute -> KIAPId.

                // Get IAP id from CM server.

                err = KErrNotReady;

                a = 0;

                TUint iapId( 0 );

                while( a < KPhoneRetryCount && err != KErrNone )

                    {

                    // ConnMon might not be able to provide KIAPId with the first trial.

                    if ( a )

                        {

                        User::After( KPhoneRetryTimeout ); // Don't wait on first try

                        }

                    iConnectionMonitor.GetUintAttribute(

                            connectionId,

                            KSubConnectionId,

                            KIAPId,

                            iapId,

                            status );

                    User::WaitForRequest( status );

                    err = status.Int();

                    LOGIT2("Got IAP ID %d from ConnMon <%d>", iapId, err)

                    a++;

                    }

                // For each new WLAN connection, we need to check the used IAP.

                // For a normal IAP, the IAP name is used for logging, but when

                // customer is using the 'Search for WLAN' functionality and

                // chooses a WLAN network that is not found in any current IAP,

                // the Easy WLAN IAP is used instead. This IAP has some internal

                // name, e.g. 'Easy WLAN', that should not be visible anywhere

                // in the UI. So SSID of used network is used in logging instead.

                //

                if ( err == KErrNone )

                    {

                    // Create a session with the latest version CommsDat

                    CMDBSession* db = CMDBSession::NewLC( CMDBSession::LatestVersion() );

                    db->SetAttributeMask( ECDProtectedWrite );

                    // Load IAP record

                    CCDIAPRecord* iapRecord = static_cast<CCDIAPRecord*>(

                            CCDRecordBase::RecordFactoryL( KCDTIdIAPRecord ) );

                    CleanupStack::PushL( iapRecord );

                    iapRecord->SetRecordId( iapId );

                    iapRecord->LoadL( *db );

                    LOGIT0("Read IAP record from CommsDat")

                    // Load wlan service record

                    CCDWlanServiceRecord* wlanRecord = new( ELeave )CCDWlanServiceRecord(

                            CCDWlanServiceRecord::TableIdL( *db ) );

                    CleanupStack::PushL( wlanRecord );

                    wlanRecord->iWlanServiceId = iapRecord->iService;

                    if ( wlanRecord->FindL( *db ) )

                        {

                        wlanRecord->LoadL( *db );

                        LOGIT0("Read WLAN record from CommsDat")

                        if ( wlanRecord->iWLanSSID.IsNull() )

                            {

                            // Used IAP is the special 'Easy WLAN' IAP, so we need to

                            // log the used WLAN network SSID instead of 'Easy WLAN'.

                            // This can be read from the 'iWLanUsedSSID'-field.

                            if ( !( wlanRecord->iWLanUsedSSID.IsNull() ) )

                                {

                                iapName = wlanRecord->iWLanUsedSSID.GetL();

                                LOGIT1("Easy WLAN detected, got SSID <%s> from CommsDat", &iapName)

                                }

                            else

                                {

                                LOGIT0("Error, Easy WLAN detected but no SSID found from CommsDat")

                                }

                            }

                        else

                            {

                            // A noraml WLAN IAP, read IAP name and use it for logging

                            iapName = iapRecord->iRecordName.GetL();

                            LOGIT1("Got IAP name <%s> from CommsDat", &iapName)

                            }

                        }

                    else

                        {

                        LOGIT0("Error, WLAN record not found from CommsDat")

                        }

                    LogDataAddEventL(

                            connectionId,

                            R_LOG_CON_CONNECTED,

                            iapName,

                            R_LOG_DIR_OUT,

                            KNullDesC,

                            KLogWlanDataEventTypeUid );

                    CleanupStack::PopAndDestroy( wlanRecord );

                    CleanupStack::PopAndDestroy( iapRecord );

                    CleanupStack::PopAndDestroy( db );

                    }

                else

                    {

                    LOGIT1("FAILED to get KIAPId from ConnMon", err)

                    }

                }

            // Check if it is EXTERNAL GPRS or WCDMA.

            else if ( bearer == EBearerExternalGPRS     ||

                      bearer == EBearerExternalEdgeGPRS ||

                      bearer == EBearerExternalWCDMA )

                {

                LOGIT0("New external connection")

                TName apName;

                apName.FillZ();

                apName.Zero();

                err = KErrNotReady;

                a = 0;

                // We loop until the retry count is reached or

                // we get a name with length > 0

                // This is because the connection monitor asks the PSD Fax

                // for the name and PSD fax sometines returns an empty string