/*

* Copyright (c) 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:  This is the model class for the Browser Test Plugin, which

*                tests HTTP functionality.

*

*/

// System Include Files

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <logfilterandeventconstants.hrh>

#endif

#include <centralrepository.h>              // CRepository

#include <cmmanager.h>                      // RCmManager

#include <cmdestination.h>                  // RCmDestination

#include <cmconnectionmethod.h>             // RCmConnectionMethod

#include <cmpluginpacketdatadef.h>          // Connection Manager Defs

#include <cmconnectionmethoddef.h>          // Connection Manager Defs

#include <es_sock.h>                        // RSocketServ, RConnection

#include <stringpool.h>                     // RStringPool

#include <httpstringconstants.h>            // HTTP Strings

#include <http/rhttpconnectioninfo.h>       // RHTTPConnectionInfo

#include <http/rhttpsession.h>              // RHTTPSession

#include <http/rhttptransaction.h>          // RHTTPTransaction

#include <http/thttpevent.h>                // THTTPEvent

#include <uri8.h>                           // TUriParser8

#include <logwrap.h>                        // CLogEvent

#include <logcli.h>                         // CLogFilter

#include <DiagResultsDatabaseItem.h>        // CDiagResultsDatabaseItem

#include <DiagFrameworkDebug.h>             // Debugging Macros

#include <diaglogeventeraser.h>             // CDiagLogEventEraser

#include <commdb.h>

// User Include Files

#include "diagbrowserpluginmodel.h"         // CDiagBrowserPluginModel

#include "diagbrowserpluginmodelobserver.h" // CDiagBrowserPluginModelObserver

#include "diagbrowserpluginprivatecrkeys.h" // CenRep keys

#include "diagbrowserplugin.pan"            // Panic

#include "diagbrowserplugin.hrh"

#include <devdiagbrowserpluginrsc.rsg>  

// Local Constants

const TInt KConnArrayGranularity =          ( 3 );

const TInt KMicroSecondsInMilliseconds =    ( 1000 );

const TInt KHttpResponseCodeOk =            ( 200 );

#ifdef __WINS__

const TInt KEmulatorDynamicIpApId =         ( 11 );

#endif // __WINS__

// ============================ GLOBAL FUNCTIONS =============================

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

// Static two-phase constructor.

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

//

CDiagBrowserPluginModel* CDiagBrowserPluginModel::NewL(

    MDiagBrowserPluginModelObserver& aObserver )

    {

    LOGSTRING( "CDiagBrowserPluginModel::NewL()" )

    CDiagBrowserPluginModel* self = new( ELeave ) CDiagBrowserPluginModel(

        aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor.

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

//

CDiagBrowserPluginModel::~CDiagBrowserPluginModel()

    {

    LOGSTRING( "CDiagBrowserPluginModel::~CDiagBrowserPluginModel()" )

    // Stop any outstanding requests.

    Cancel();

    // Free memory reserved by the model.

    delete iTimer;

    delete iLogEraser;

	delete iWaitDialog;

    // Close any open sessions.

    iHttpTransaction.Close();

    iHttpSession.Close();

    iConnection.Close();

    iSocketServ.Close();

    }

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

// Initiates the browser test.

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

//

void CDiagBrowserPluginModel::RunBrowserTestL()

    {

    LOGSTRING( "CDiagBrowserPluginModel::RunBrowserTestL()" )

    // Mark the start time for removing the logs.

    iStartTime.UniversalTime();

    iRetryCount = 0;

    iTimerCalled = 0;

    // Read Central Repository keys.

    if ( !ReadCenRepKeysL() )

        {

        HandleTestEndL( CDiagResultsDatabaseItem::EFailed );

        return;

        }

    /* Read APN data.

    GetConnectionMethodL( iPrimaryConnection );

    GetConnectionMethodL( iSecondaryConnection );*/

    //iTimeoutValue = 30000;

    // Open the connection.

    if ( !OpenAndStartConnectionL() )

        {

        HandleTestEndL( CDiagResultsDatabaseItem::EFailed );

        return;

        }

    }

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

// Returns the total number of execution steps.

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

TUint CDiagBrowserPluginModel::TotalSteps()

    {

    LOGSTRING( "CDiagBrowserPluginModel::TotalSteps()" )

    return EDiagBrowserStateMax;

    }

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

// The default constructor.

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

//

CDiagBrowserPluginModel::CDiagBrowserPluginModel(

    MDiagBrowserPluginModelObserver& aObserver )

:   CActive( EPriorityStandard ),

    iObserver( aObserver )

    {

    LOGSTRING( "CDiagBrowserPluginModel::CDiagBrowserPluginModel()" )

    CActiveScheduler::Add( this );

    }

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

// The second phase constructor.

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

//

void CDiagBrowserPluginModel::ConstructL()

    {

    LOGSTRING( "CDiagBrowserPluginModel::ConstructL()" )

    // Open the connection to the Socket Server.

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

    User::LeaveIfError( iConnection.Open( iSocketServ ) );

    idialogOn = EFalse; idialogDismissed = EFalse;

    }

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

// Reads and stores the browser test's Central Repository Keys.

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

//

TBool CDiagBrowserPluginModel::ReadCenRepKeysL()

    {

    LOGSTRING( "CDiagBrowserPluginModel::ReadCenRepKeysL()" )

    // Create a Central Repository object.

    CRepository* repository = CRepository::NewLC(

        KCRUidDiagBrowserTestPlugin );

    // Get the data.

   /* if ( repository->Get( KDiagBrowserApnPrimary,

                          iPrimaryConnection.iApn ) != KErrNone ||

         repository->Get( KDiagBrowserApnSecondary,

                          iSecondaryConnection.iApn ) != KErrNone ||

         repository->Get( KDiagBrowserProxyAddress,

                          iProxyAddress ) != KErrNone ||

         repository->Get( KDiagBrowserProxyPort,

                          iProxyPort ) != KErrNone ||*/

         if( repository->Get( KDiagBrowserResponseTimeout,

                          iTimeoutValue ) != KErrNone ||

        repository->Get( KDiagBrowserUri,

                          iUri ) != KErrNone )

        {

        LOGSTRING( "CDiagBrowserPluginModel::ReadCenRepKeysL() - CenRep read"

                   L" failed." )

        CleanupStack::PopAndDestroy( repository );

        return EFalse;

        }

   /* LOGSTRING3(

        "CDiagBrowserPluginModel::ReadCenRepKeysL() - Primary APN '%S'"

        L" Secondary APN '%S'",

        &iPrimaryConnection.iApn,

        &iSecondaryConnection.iApn )

    LOGSTRING3(

        "CDiagBrowserPluginModel::ReadCenRepKeysL() - Proxy '%S:%d'",

        &iProxyAddress,

        iProxyPort )*/

    LOGSTRING3(

        "CDiagBrowserPluginModel::ReadCenRepKeysL() - Timeout %d, Uri '%S'",

        iTimeoutValue,

        &iUri )

    CleanupStack::PopAndDestroy( repository );

    return ETrue;

    }

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

// Finds the connection method that corresponds to the data supplied in the

// argument.

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

//

void CDiagBrowserPluginModel::GetConnectionMethodL(

    TBrowserConnectionMethodData& aData )

    {

    LOGSTRING( "CDiagBrowserPluginModel::GetConnectionMethodL()" )

    // Look for matching connection methods.

    RCmManager connManager;

    connManager.OpenLC();

    // Get a list of all the destinations.

    RArray< TUint32 > connArray = RArray< TUint32 >( KConnArrayGranularity );

    CleanupClosePushL( connArray );

    connManager.AllDestinationsL( connArray );

    // Look through all the destinations' connection methods and see if any of

    // them match the CenRep data.

    for ( TInt i = 0; i < connArray.Count() && !aData.iIsValid ; i++ )

        {

        RCmDestination destination = connManager.DestinationL(

            connArray[ i ] );

        CleanupClosePushL( destination );

        LOGSTRING4( "CDiagBrowserPluginModel::GetConnectionMethodL() -"

                    L" Destination %d / %d, %d method(s)",

                    i + 1,

                    connArray.Count(),

                    destination.ConnectionMethodCount() )

        // Don't use any hidden destinations, because they are not visible to

        // the user.

        if ( destination.IsHidden() )

            {

            LOGSTRING( "CDiagBrowserPluginModel::GetConnectionMethodL() -"

                       L" Skipping hidden destination" )

            CleanupStack::PopAndDestroy(); // destination

            continue;

            }

        for ( TInt j = 0;

              j < destination.ConnectionMethodCount() && !aData.iIsValid;

              j++ )

            {

            RCmConnectionMethod method = destination.ConnectionMethodL( j );

            CleanupClosePushL( method );

            // This call is trapped because not all connection methods support

            // the data we're querying, and the leave should not be propagated

            // up because that would not be a reason for test failure.

            TRAP_IGNORE( CheckConnectionMatchL( method, aData ) )

            CleanupStack::PopAndDestroy(); // method

            }

        CleanupStack::PopAndDestroy(); // destination

        }

    // Get a list of all the uncategorized connection methods.

    connArray.Reset();

    connManager.ConnectionMethodL( connArray );

    LOGSTRING2( "CDiagBrowserPluginModel::GetConnectionMethodL() -"

                L" Checking %d uncategorized method(s)",

                connArray.Count() )

    // Look through all the uncategorized connection methods and see if any

    // of them match match the CenRep data.

    for ( TInt i = 0; i < connArray.Count() && !aData.iIsValid; i++ )

        {

        RCmConnectionMethod method = connManager.ConnectionMethodL(

            connArray[ i ] );

        CleanupClosePushL( method );

        // This call is trapped because not all connection methods support

        // the data we're querying, and the leave should not be propagated

        // up because that would not be a reason for test failure.

        TRAP_IGNORE( CheckConnectionMatchL( method, aData ) )

        CleanupStack::PopAndDestroy(); // method

        }

    CleanupStack::PopAndDestroy(); // connArray

    CleanupStack::PopAndDestroy(); // connManager

    }

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

// Checks if the connection method matches the data supplied in the argument.

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

//

void CDiagBrowserPluginModel::CheckConnectionMatchL(

    const RCmConnectionMethod& aMethod,

    TBrowserConnectionMethodData& aData ) const

    {

    LOGSTRING( "CDiagBrowserPluginModel::CheckConnectionMatchL()" )

    HBufC* name = aMethod.GetStringAttributeL(

        CMManager::ECmName );

    CleanupStack::PushL( name );

#ifdef __WINS__

    HBufC* apn = HBufC::NewL( 1 );

#else

    HBufC* apn = aMethod.GetStringAttributeL(

        CMManager::EPacketDataAPName );

#endif // __WINS__

    CleanupStack::PushL( apn );

    TInt type = aMethod.GetIntAttributeL(

        CMManager::ECmBearerType );

    TBool hidden = aMethod.GetBoolAttributeL(

        CMManager::ECmHidden );

    HBufC* proxy = aMethod.GetStringAttributeL(

        CMManager::ECmProxyServerName );

    CleanupStack::PushL( proxy );

    TInt port = aMethod.GetIntAttributeL(

        CMManager::ECmProxyPortNumber );

    TUint apId = aMethod.GetIntAttributeL(

        CMManager::ECmIapId );

    LOGSTRING4(

        "CDiagBrowserPluginModel::CheckConnectionMatchL() - CM"

        L" Name '%S', Type '0x%08x', Hidden '%d'", name, type, hidden )

    LOGSTRING5( "CDiagBrowserPluginModel::CheckConnectionMatchL() - CM"

                L" APN '%S', Proxy '%S:%d', Id %d", apn, proxy, port, apId )

#ifdef __WINS__

    if ( apId == KEmulatorDynamicIpApId )

#else

    if ( apn->Compare( aData.iApn ) == 0 &&

         proxy->Compare( iProxyAddress ) == 0 &&

         port == iProxyPort &&

         type == KUidPacketDataBearerType &&

         !hidden )

#endif // __WINS__

        {

        aData.iApId = apId;

        aData.iMethodName.Copy( *name );

        aData.iIsValid = ETrue;

        LOGSTRING2( "CDiagBrowserPluginModel::CheckConnectionMatchL() - Found"

                    L" AP with id %d.", aData.iApId )

        }

    CleanupStack::PopAndDestroy( proxy );

    CleanupStack::PopAndDestroy( apn );

    CleanupStack::PopAndDestroy( name );

    }

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

// Starts or resets the connection timeout timer.

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

//

void CDiagBrowserPluginModel::StartConnectionTimerL()

    {

    LOGSTRING( "CDiagBrowserPluginModel::StartConnectionTimerL()" )

    // Create the timer, or cancel an existing timer.

    if ( !iTimer )

        {

        iTimer = CPeriodic::NewL( EPriorityHigh );

        }

    else

        {

        iTimer->Cancel();

        }

    // Start the timer.

    iTimer->Start(

        TTimeIntervalMicroSeconds32(

            iTimeoutValue * KMicroSecondsInMilliseconds ),

        TTimeIntervalMicroSeconds32( 0 ),

        TCallBack( TimerExpired, this ) );

    iTimerCalled++;

    }

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

// Updates the plugin's state and reports progress to the observer.

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

//

void CDiagBrowserPluginModel::SetStateL( TDiagBrowserState aTargetState )

    {

    LOGSTRING3( "CDiagBrowserPluginModel::SetStateL( %d ) - iState %d",

                aTargetState,

                iState )

    // Check for bad state transitions.

    switch ( aTargetState )

        {

        case EDiagBrowserStateConnectingBearer:

            __ASSERT_ALWAYS( iState == EDiagBrowserStateInitial,

                             Panic( EDiagBrowserPluginBadState ) );

            break;

        case EDiagBrowserStateConnectingServer:

            __ASSERT_ALWAYS( iState == EDiagBrowserStateConnectingBearer,

                             Panic( EDiagBrowserPluginBadState ) );

            break;

        case EDiagBrowserStateErasingLog:

            __ASSERT_ALWAYS( iState != EDiagBrowserStateInitial,

                             Panic( EDiagBrowserPluginBadState ) );

            break;

        default:

            Panic( EDiagBrowserPluginBadState );

        }

    // Update the state.  Send progress to the observer.

    iState = aTargetState;

    iObserver.TestProgressL( aTargetState );

    }

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

// Callback function for handling timer events.

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

//

TInt CDiagBrowserPluginModel::TimerExpired( TAny* aPtr )

    {

    LOGSTRING2( "CDiagBrowserPluginModel::TimerExpired( 0x%x )", aPtr )

    __ASSERT_ALWAYS( aPtr, Panic( EDiagBrowserPluginInternal ) );

    CDiagBrowserPluginModel* myThis =

        static_cast< CDiagBrowserPluginModel* >( aPtr );

    // Stop the timer to prevent further undesired callbacks.

    myThis->iTimer->Cancel();

    myThis->TimerCleanUp();

    // Try to continue test execution by retrying the secondary connection.

    //TRAPD( error, myThis->RetryConnectionL() );

    return KErrNone;

    }

void CDiagBrowserPluginModel::TimerCleanUp()

{

	if (iState == EDiagBrowserStateConnectingBearer)

	{

		if(iTimerCalled<=1)

		StartConnectionTimerL();

		else

		iConnection.Stop( RConnection::EStopAuthoritative );

	}

	else if (iState == EDiagBrowserStateConnectingServer)

	iHttpTransaction.Cancel();

}

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

// Opens the network connection.  This may be called multiple times if a

// retry is necessary.

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

TBool CDiagBrowserPluginModel::OpenAndStartConnectionL()

    {

    LOGSTRING( "CDiagBrowserPluginModel::OpenAndStartConnectionL()" )

    // Check if there is a valid connection to use.

    /*if ( !iPrimaryConnection.iIsValid && !iSecondaryConnection.iIsValid )

        {

        LOGSTRING( "CDiagBrowserPluginModel::OpenAndStartConnectionL() - No"

                   L" valid connections." )

        return EFalse;

        }

        */

    // Reset the connection.

    iHttpTransaction.Close();

    iHttpSession.Close();

    iConnection.Stop();

    iState = EDiagBrowserStateInitial;

    iConnectionPrefs.SetDialogPreference(ECommDbDialogPrefPrompt);//ECommDbDialogPrefDoNotPrompt ECommDbDialogPrefPrompt

    LOGSTRING("SetDialogPreference( ECommDbDialogPrefPrompt)");

    iConnectionPrefs.SetDirection( ECommDbConnectionDirectionOutgoing );

    //iConnectionPrefs.SetIapId( iapID );

    //iConnectionPrefs.SetBearerSet(ECommDbBearerGPRS);

    iConnection.Start( iConnectionPrefs, iStatus );

    SetActive();

	ShowProgressNoteL();

    // Start the timer and set the state to notify progress.

    StartConnectionTimerL();

    SetStateL( EDiagBrowserStateConnectingBearer );

    return ETrue;

    }

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

// Handles ending the test by deleting the logs, if necessary, and informing

// the observer.

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

void CDiagBrowserPluginModel::HandleTestEndL(

    CDiagResultsDatabaseItem::TResult aResult )

    {

    LOGSTRING2( "CDiagBrowserPluginModel::HandleTestEndL( %d )", aResult )

    // Store the result, to return when log deletion completes.

    iResult = aResult;

    // Delete the logs, if necessary.

    if ( iState != EDiagBrowserStateInitial )

        {

        if ( !iLogEraser )

            {

            iLogEraser = CDiagLogEventEraser::NewL( *this );

            }