/*

* 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 class module for the PDP Test Engine

*

*/

// INCLUDE FILES

#include <DiagFrameworkDebug.h>                 // debug macros

#include "diagpdptestengine.h"

#include <cmpluginpacketdatadef.h>

//#include <AknLists.h>

//#include <BADESCA.H >

//#include <aknPopup.h> 

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

//const TInt KConnArrayGranularity = ( 3 );

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ==============================

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

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

// CDiagPDPTestEngine::CDiagPDPTestEngine()

//

// C++ default constructor

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

CDiagPDPTestEngine::CDiagPDPTestEngine() 

    : CActive(CActive::EPriorityUserInput)

    {

    // no implementation needed 

    }

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

// CDiagPDPTestEngine::~CDiagPDPTestEngine()

//

// C++ default destructor

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

CDiagPDPTestEngine::~CDiagPDPTestEngine()

    {

    // no implementation needed

    }   

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

// CDiagPDPTestEngine::RunL()

//

// Handle asynchronous requests

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

void CDiagPDPTestEngine::RunL()

    {

    // no implementation needed 

    } 

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

// CDiagPDPTestEngine::DoCancel()

//

// Handle cancellation of asynchronous requests

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

void CDiagPDPTestEngine::DoCancel()

    {

    // no implementation needed 

    }

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

// CDiagPDPTestEngine::CheckAPNsInConnectionManagerL()

//

// 

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

TBool CDiagPDPTestEngine::CheckAPNsInConnectionManagerL()

    {

    LOGSTRING( "CDiagPDPTestEngine::CheckAPNsInConnectionManagerL()" );

    /*RArray<TUint32> idArray;

    CleanupClosePushL( idArray );

    CDesCArrayFlat* nameArray = new (ELeave) CDesCArrayFlat(16);

    CleanupStack::PushL( nameArray );

    // Get IAP names and ids from the database

    CCommsDatabase* TheDb = CCommsDatabase::NewL( EDatabaseTypeIAP );

    CleanupStack::PushL( TheDb );

    TheDb->ShowHiddenRecords();

    CCommsDbTableView* view = TheDb->OpenTableLC( TPtrC(IAP) );

    TBuf<40> name;

    TUint32 id,aId;

    TInt res = view->GotoFirstRecord();

    while( res == KErrNone )

    {

        view->ReadTextL( TPtrC(COMMDB_NAME), name );

        view->ReadUintL( TPtrC(COMMDB_ID), id );

        idArray.Insert( id, 0 );

        nameArray->InsertL( 0, name );

        res = view->GotoNextRecord();

        RDebug::Print(_L("IAP name, id: %S, %d"), &name, id);

    }

    CleanupStack::PopAndDestroy( view ); // view

    CleanupStack::PopAndDestroy( TheDb ); // TheDb

    // Create listbox and PUSH it.

    CEikTextListBox* list = new(ELeave) CAknSinglePopupMenuStyleListBox;

    CleanupStack::PushL( list );

    // Create popup list and PUSH it.

    CAknPopupList* popupList = CAknPopupList::NewL(

        list, R_AVKON_SOFTKEYS_OK_CANCEL,

        AknPopupLayouts::EMenuWindow);

    CleanupStack::PushL( popupList );

    // initialize listbox.

    list->ConstructL( popupList, CEikListBox::ELeftDownInViewRect );

    list->CreateScrollBarFrameL( ETrue );

    list->ScrollBarFrame()->SetScrollBarVisibilityL(

        CEikScrollBarFrame::EOff,

        CEikScrollBarFrame::EAuto );

    // Set listitems.

    CTextListBoxModel* model = list->Model();

    model->SetItemTextArray( nameArray );

    model->SetOwnershipType( ELbmDoesNotOwnItemArray );

    // Set title

    popupList->SetTitleL( _L("Select IAP:") );

    // Show popup list.

    TInt popupOk = popupList->ExecuteLD();

    CleanupStack::Pop( popupList ); // popupList

    if ( popupOk )

        {

        TInt index = list->CurrentItemIndex();

        aId = idArray[index];

        }

    CleanupStack::PopAndDestroy( 3, &idArray );  // list, nameArray, idArray

    if(popupOk != EFalse)

					{

					iIAPiddefault = aId;

					}

		return popupOk;*/

       /*CCommsDatabase* cdb = CCommsDatabase::NewL(EDatabaseTypeIAP);

       CleanupStack::PushL(cdb);

       LOGSTRING("CCommsDatabase::NewL");

       CApDataHandler* apDataHandler = CApDataHandler::NewLC(*cdb);

       LOGSTRING("CApDataHandler::NewLC");

       iIAPiddefault = apDataHandler->DefaultL(EFalse);

       LOGSTRING2( "CApDataHandler->Default %d",iIAPiddefault );

       CleanupStack::PopAndDestroy(2);

       LOGSTRING( "pop/destroy 2");

       return ETrue;*/

/*    LOGSTRING( "CDiagPDPTestEngine::CheckAPNsInConnectionManagerL()" )

    // Reset the arrays to hold valid IAP Ids

    iPrimaryAPNIapIdArray.Reset();;

    iSecondaryAPNIapIdArray.Reset();    

    // Opens a session with the connection manager

    RCmManager connManager; 

    connManager.OpenLC();

    LOGSTRING( "CDiagPDPTestEngine session with connection manager opened." )

    // create a conneciton array to hold the Ids of connections    

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

    CleanupClosePushL( connArray );

    // Get a list of all the destinations

    LOGSTRING( "CDiagPDPTestEngine Get a list of all the destinations." )

    connManager.AllDestinationsL( connArray );    

    TInt numberOfDestinations = connArray.Count();    

    LOGSTRING2( "CDiagPDPTestEngine number of destinations = %d", numberOfDestinations )

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

    // them match the CenRep data.

    for ( TInt i = 0; i < numberOfDestinations; i++ )

        {

        RCmDestination destination = connManager.DestinationL( connArray[ i ] );

        CleanupClosePushL( destination );

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

        // the user.

        if ( destination.IsHidden() )

            {

            LOGSTRING2( "CDiagPDPTestEngine: Destination number %d is hidden, hence ignoring it", i)

            CleanupStack::PopAndDestroy(); // destination

            continue;

            }

        // get the number of connection methods with this destination

        TInt numberOfConnectionMethods = destination.ConnectionMethodCount();

        LOGSTRING3( "CDiagPDPTestEngine For destination %d, number of connection methods are %d", i, numberOfConnectionMethods )

        for ( TInt j = 0; j < numberOfConnectionMethods; 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 ) )

            CleanupStack::PopAndDestroy(); // method

            }

        CleanupStack::PopAndDestroy(); // destination

        }        

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

    LOGSTRING( "CDiagPDPTestEngine : Get a list of all the uncategorized connection methods." )

    connArray.Reset();

    connManager.ConnectionMethodL( connArray );

    TInt numberOfUncategorizedConnectionMethods = connArray.Count();    

    LOGSTRING2( "CDiagPDPTestEngine : number of uncategorized connection methods = %d", numberOfUncategorizedConnectionMethods)

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

    // of them match match the CenRep data.

    for ( TInt i = 0; i < numberOfUncategorizedConnectionMethods; 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) )

        CleanupStack::PopAndDestroy(); // method

        }

    CleanupStack::PopAndDestroy(); // connArray

    CleanupStack::PopAndDestroy(); // connManager

    // check if atleast one occurrence each of the primary APN or the secondary APN was found in CommsDB

    if( (iPrimaryAPNIapIdArray.Count() > 0) || (iSecondaryAPNIapIdArray.Count() > 0) )

        {

        return ETrue;

        }

    else

        {

        return EFalse;

        }

    */

    return ETrue; //compiler warning

    }

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

// CDiagPDPTestEngine::CheckConnectionMatchL()

//

//

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

void CDiagPDPTestEngine::CheckConnectionMatchL(const RCmConnectionMethod& aMethod)

    {

    LOGSTRING( "CDiagBrowserPluginModel::CheckConnectionMatchL()" )

    HBufC* name = aMethod.GetStringAttributeL(

        CMManager::ECmName );

    CleanupStack::PushL( name );

    HBufC* apn = aMethod.GetStringAttributeL(

        CMManager::EPacketDataAPName );

    CleanupStack::PushL( apn );

    TInt type = aMethod.GetIntAttributeL(

        CMManager::ECmBearerType );

    TBool hidden = aMethod.GetBoolAttributeL(

        CMManager::ECmHidden );

    TUint32 apId = aMethod.GetIntAttributeL(

        CMManager::ECmIapId );   

    LOGSTRING5(

        "CDiagBrowserPluginModel::CheckConnectionMatchL() "

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

    if ( ( apn->Compare( iCenrepPrimaryAPN ) == 0 ) && 

         type == KUidPacketDataBearerType &&

         !hidden )

        {

        LOGSTRING( "CDiagBrowserPluginModel connection matches primary APN, adding to primary IAP array" )

        iPrimaryAPNIapIdArray.Append(apId);

        }

    if ( ( apn->Compare( iCenrepSecondaryAPN ) == 0 ) && 

         type == KUidPacketDataBearerType &&

         !hidden )

        {

        LOGSTRING( "CDiagBrowserPluginModel connection matches secondary APN, adding to secondary IAP array" )

        iSecondaryAPNIapIdArray.Append(apId);

        }        

    CleanupStack::PopAndDestroy( apn );

    CleanupStack::PopAndDestroy( name );

    }

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

// CDiagPDPTestEngine::FindActiveConnectionsL()

//

// this function returns ETrue if an already active connection is found using 

// the IAP ids which match with the specified APNs, else it returns EFalse

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

TBool CDiagPDPTestEngine::FindActiveConnectionsL() 

    {

    LOGSTRING( "CDiagPDPTestEngine::FindActiveConnectionsL");

    TBool result = EFalse;   

    TUint connectionCount = 0;

    TPckgBuf<TConnectionInfo> connectionInfo;

    User::LeaveIfError(

        iConnection.EnumerateConnections(connectionCount));

    LOGSTRING("iConnection.EnumerateConnections");

    if(connectionCount > 0)

        {

        // there is atleast one active connection

        // iterate through each active connection

        for(TUint count = 1 ; count <= connectionCount; count++)

            {

            User::LeaveIfError(

                iConnection.GetConnectionInfo(count, connectionInfo));               

            // test if the IAP Id of this active connection matches with one of the IAP ids in 

            // primary array or secondary array

            /*if( ((iPrimaryAPNIapIdArray.Find( connectionInfo().iIapId)) != KErrNotFound ) || 

                ((iSecondaryAPNIapIdArray.Find( connectionInfo().iIapId)) != KErrNotFound ) )*/

	        if (iIAPiddefault == connectionInfo().iIapId)

                {

                // the IAP ID of the current active connection has matched with the one of the IAPs in primary array or secondary array

                // data connection has PASSED

                LOGSTRING("IAP ID of the current active connection has matched");

                result = ETrue;

                break; //break from the for loop

                }

                else

                {

                // do nothing, look for next active connection

                }

            }

        }

    else

        {

        // no active connection found

        result = EFalse;        

        }

    return result;

    }

// End of File