/*

* Copyright (c) 2002 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:  Declaration of the CApSelect class.

*

*/

// INCLUDE FILES

#include <cdbcols.h>

#include <commdb.h>

#include <eikdef.h>

#include <d32dbms.h>

#include <featmgr.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <ProtectDB.h>

#else

#include <comms-infras/commdb/protection/protectdb.h>

#endif

#include <etelpckt.h>

#ifdef __TEST_USE_SHARED_DATA

    #include <sharedDataValues.h>

#endif // __TEST_USE_SHARED_DATA

#include "ApListItem.h"

#include "ApListItemList.h"

#include "ApSelect.h"

#include "ApUtils.h"

#include "ApEngineCommons.h"

#include <ApEngineConsts.h>

#include "ApEngineLogger.h"

#include "ApListItemKey.h"

// CONSTANTS

const TInt KCursorNullPos = 0;

const TInt KItemCountNull = 0;

#ifdef __TEST_USE_SHARED_DATA

    // General Settings UID, Hardcoded

    const TUid KGeneralSettingsUid={0X100058EC};

#endif // __TEST_USE_SHARED_DATA

const TInt KDIALOUT     = 0;

const TInt KGPRSIN      = 1;

const TInt KGPRSOUT     = 2;

const TInt KCDMA_ISP    = 3;

const TInt KVPN         = 4;

const TInt  KUID        = 0;

const TInt  KISPTYPE    = 1;

const TInt  KBEARERTYPE = 2;

// LOCAL CONSTANTS AND MACROS

// LOCAL FUNCTION PROTOTYPES

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

// Two-phased constructor.

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

// CApSelect::NewLC

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

//

EXPORT_C CApSelect* CApSelect::NewLC( CCommsDatabase& aDb,

                                     TInt aIspFilter,

                                     TInt aBearerFilter,

                                     TInt aSortType )

    {

    CLOG( ( ESelect, 0, _L( "-> CApSelect::NewLC" ) ) );

    CApSelect* db = CApSelect::NewLC( aDb, aIspFilter, 

                                      aBearerFilter, aSortType, EIPv4 );

    CLOG( ( ESelect, 1, _L( "<- CApSelect::NewLC" ) ) );

    return db;

    }

// Destructor

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

// CApSelect::~CApSelect

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

//

EXPORT_C CApSelect::~CApSelect()

    {

    CLOG( ( ESelect, 0, _L( "-> CApSelect::~CApSelect" ) ) );

    if ( iExt )

        {

        if ( iExt->iIsFeatureManagerInitialised )

            {

            FeatureManager::UnInitializeLib();

            }

        }

    if ( iApList )

        {

        iApList->ResetAndDestroy();

        delete iApList;

        }

    delete iExt;

    CLOG( ( ESelect, 1, _L( "<- CApSelect::~CApSelect" ) ) );

    }

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

// might leave.

//

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

// CApSelect::CApSelect

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

//

EXPORT_C CApSelect::CApSelect()

:iCursor( KCursorNullPos ),

iCount( KItemCountNull )

    {

    }

// Symbian OS default constructor can leave.

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

// CApSelect::ConstructL

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

//

EXPORT_C void CApSelect::ConstructL( CCommsDatabase& aDb,

                                 TInt aIspFilter,

                                 TInt aBearerFilter,

                                 TInt aSortType )

    {

    ConstructL( aDb, aIspFilter, aBearerFilter, 

                aSortType, EIPv4, EVpnFilterBoth );

    }

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

// CApSelect::SetFilters

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

//

EXPORT_C void CApSelect::SetFiltersL( TInt aIspFilter,

                                    TInt aBearerFilter,

                                    TInt aSortType )

    {

    SetFiltersL( aIspFilter, aBearerFilter, aSortType, 

                 iExt->iReqIpvType, iExt->iVpnFilterType );

    }

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

// CApSelect::IspTypeFilter

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

//

EXPORT_C TInt CApSelect::IspTypeFilter()

    {

    CLOG( ( ESelect, 0, _L( "<-> CApSelect::IspTypeFilter" ) ) );

    return iIsp;

    }

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

// CApSelect::BearerFilter

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

//

EXPORT_C TInt CApSelect::BearerFilter()

    {

    CLOG( ( ESelect, 0, _L( "<-> CApSelect::BearerFilter" ) ) );

    return iBearer;

    }

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

// CApSelect::SortOrder

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

//

EXPORT_C TInt CApSelect::SortOrder()

    {

    CLOG( ( ESelect, 0, _L( "<-> CApSelect::SortOrder" ) ) );

    return iSort;

    }

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

// CApSelect::MoveToFirst

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

//

EXPORT_C TBool CApSelect::MoveToFirst()

    {

    CLOG( ( ESelect, 0, _L( "<-> CApSelect::MoveToFirst" ) ) );

    iCursor = 0;

    return ( iExt->iMaxIndex >= 0 );

    }

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

// CApSelect::MoveNext

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

//

EXPORT_C TBool CApSelect::MoveNext()

    {

    CLOG( ( ESelect, 0, _L( "<-> CApSelect::MoveNext" ) ) );

    if ( iCursor < iExt->iMaxIndex )

        {

        iCursor++;

        return ETrue;

        }

    return EFalse;

    }

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

// CApSelect::MoveLast

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

//

EXPORT_C TBool CApSelect::MoveLast()

    {

    CLOG( ( ESelect, 0, _L( "<-> CApSelect::MoveLast" ) ) );

    iCursor = iExt->iMaxIndex;

    return ( iCursor >= 0 );

    }

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

// CApSelect::MovePrev

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

//

EXPORT_C TBool CApSelect::MovePrev()

    {

    CLOG( ( ESelect, 0, _L( "<-> CApSelect::MovePrev" ) ) );

    if ( iCursor>0 )

        {

        iCursor--;

        return ETrue;

        }

    return EFalse;

    }

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

// CApSelect::Count

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

//

EXPORT_C TUint32 CApSelect::Count()

    {

    CLOG( ( ESelect, 0, _L( "<-> CApSelect::Count" ) ) );

    return iApList->Count( );

    }

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

// CApSelect::Name

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

//

EXPORT_C const TDesC& CApSelect::Name()

    {

    CLOG( ( ESelect, 0, _L( "<-> CApSelect::Name" ) ) );

    return *iApList->At( iCursor )->iName;

    }

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

// CApSelect::Uid

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

//

EXPORT_C TUint32 CApSelect::Uid()

    {

    CLOG( ( ESelect, 0, _L( "<-> CApSelect::Uid" ) ) );

    return iApList->At( iCursor )->iUid;

    }

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

// CApSelect::Type

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

//

EXPORT_C TCommsDbIspType CApSelect::Type()

    {

    CLOG( ( ESelect, 0, _L( "<-> CApSelect::Type" ) ) );

    return iApList->At( iCursor )->iIspType;

    }

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

// CApSelect::BearerType

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

//

EXPORT_C TApBearerType CApSelect::BearerType()

    {

    CLOG( ( ESelect, 0, _L( "<-> CApSelect::BearerType" ) ) );

    return iApList->At( iCursor )->iBearerType;

    }

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

// CApSelect::AllListItemDataL

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

//

EXPORT_C TInt CApSelect::AllListItemDataL( CApListItemList& aList )

    {

    CLOG( ( ESelect, 0, _L( "-> CApSelect::AllListItemDataL" ) ) );

    aList.ResetAndDestroy();

    CApListItem* item=NULL;

    TInt i;

    TInt count = iApList->Count();

    for ( i=0; i<count; i++ )

        {

        item = CApListItem::NewLC( ( *iApList )[i] );

        aList.AppendL( item );

        CleanupStack::Pop( item ); // item owned by aList !

        }

    CLOG( ( ESelect, 1, _L( "<- CApSelect::AllListItemDataL" ) ) );

    return aList.Count();

    }

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

// CApSelect::IsReadOnly

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

//

EXPORT_C TBool CApSelect::IsReadOnly() const

    {

    CLOG( ( ESelect, 0, _L( "<-> CApSelect::IsReadOnly" ) ) );

    return iApList->At( iCursor )->iExt->iReadOnly;

    }

// ================= OTHER EXPORTED FUNCTIONS ==============

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

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

// CApSelect::DoUpdate

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

//

TInt CApSelect::DoUpdateL()

    {

    CLOG( ( ESelect, 0, _L( "-> CApSelect::DoUpdateL" ) ) );

    // filtering criteria:

    // Bearer type

    // Isp type

    // HasMandatory

    // + ordering (name or UID...)

    // first filter WAP_ACCESS_POINT table and order it

    TBool OwnTransaction = ApCommons::StartPushedTransactionLC( *iDb );

    if ( !OwnTransaction )

        {

        __ASSERT_DEBUG( EFalse, ApCommons::Panic( ENotSupported ) );

        User::Leave( KErrNotSupported );

        }

    CCommsDbTableView* wapt = NULL;

    CCommsDbTableView* ipbearert = NULL;

    CCommsDbTableView* iapt = NULL;

                                     // csdOut, GprsIn, gprsOut, cdma,  VPN

    CCommsDbTableView* isptables[5] = { NULL,   NULL,   NULL,   NULL,   NULL};

    wapt = GetFilteredSortedWapTableViewLC();

    TInt err = wapt->GotoFirstRecord(); // OK.

    if ( ( err == KErrNone ) || ( err == KErrNotFound ) )

        { // even if it is empty, we must clear the list.

        // otherwise, Leave

        // fill up list. First empty it

        iApList->ResetAndDestroy();

        iCount = 0;

        if ( err == KErrNone )

            { // have some, we can go on...

            // First get ip_bearer table, then iap, then isp & gprs, if needed

            if ( ( iBearer & EApBearerTypeCSD ) ||

                 ( iBearer & EApBearerTypeHSCSD ) ||

                 ( iBearer & EApBearerTypeGPRS ) ||

                 ( iExt->iCdma && ( iBearer & EApBearerTypeCDMA ) ) )

                {

                ipbearert = GetFilteredSortedIpBearerTableViewLC();

                if ( ipbearert )

                    {

                    err = ipbearert->GotoFirstRecord();

                    if ( err == KErrNone )

                        {

                        if ( ( iBearer & EApBearerTypeCSD ) ||

                             ( iBearer & EApBearerTypeHSCSD ) )

                            {

                            isptables[KDIALOUT] =

                                GetFilteredSortedIspOutTableViewLC();

                            }

                        if ( ( iBearer & EApBearerTypeGPRS ) )

                            {

                            isptables[KGPRSIN] =

                                GetFilteredSortedGprsTableViewLC( ETrue );

                            isptables[KGPRSOUT] =

                                GetFilteredSortedGprsTableViewLC( EFalse );

                            }

                        }

                    else

                        {

                        if ( err != KErrNotFound )

                            {

                            User::LeaveIfError( err );

                            }

                        }

                    }

                }

            // get wapapids

               // get smsapids, if defined

            // get ipapids with iap ids

            // get only those iap ids from filtered database

            CArrayFixFlat<TUint32>* wapapid =

                    new ( ELeave ) CArrayFixFlat<TUint32>( 10 );

            CleanupStack::PushL( wapapid );

            GetUintValuesL( wapt, TPtrC(COMMDB_ID), *wapapid );

            // read up access point names, too, just to be as fast as we can...

            CArrayPtrFlat<HBufC>* wapapname =

                    new ( ELeave ) CArrayPtrFlat<HBufC>( 10 );

            CleanupStack::PushL( wapapname );

            GetTextValuesL( wapt, TPtrC(COMMDB_NAME), *wapapname );

            // read up start page, too, just to be as fast as we can...

            CArrayPtrFlat<HBufC>* wapstartpage =

                    new ( ELeave ) CArrayPtrFlat<HBufC>( 10 );

            CleanupStack::PushL( wapstartpage );

            // as it is LONG text...

            GetLongTextValuesL( wapt, TPtrC(WAP_START_PAGE), *wapstartpage );

            //read up Read-only flags

            CArrayFixFlat<TUint32>* protflags =

                    new ( ELeave ) CArrayFixFlat<TUint32>( 10 );

            CleanupStack::PushL( protflags );

            GetProtValuesL( wapt, *protflags );

            CArrayFixFlat<TUint32>* ipapid =

                    new ( ELeave ) CArrayFixFlat<TUint32>( 10 );

            CleanupStack::PushL( ipapid );

            GetUintValuesL( ipbearert, TPtrC(WAP_ACCESS_POINT_ID), *ipapid );

            CArrayFixFlat<TUint32>* ipiapid =

                    new ( ELeave ) CArrayFixFlat<TUint32>( 10 );

            CleanupStack::PushL( ipiapid );

            GetUintValuesL( ipbearert, TPtrC(WAP_IAP), *ipiapid );

            // What comes next:::::

            // for each table:

            // filter separately for different bearers ->

            // we know the bearer type...

            // filter separately for different ISP types ->

            // we know the ISP type...

            // now all we have to do is to 'simply' check filtered IAP with

            // the separate arrays, leave only those that present in

            // both bearer & isp array

            // fill up an array of id & an array of bearer type &

            // an array of isp type

            // after it, narrow down wap with wapbearer,

            // create items in order,

            // check items against remained iap array

            // fill up values in list.

            // bearer arrays : 0: csd, 1:hscsd, 2: gprs, 3: cdma

            TInt i( 0 );

            // an array Isp[CSDOut/GPRSIn/GPRSOut/CDMA/VPN]

            //             [COMMDB_ID, ISP_TYPE, Bearer_type]

            CArrayFixFlat<TUint32[3]>* ispArray[5];

            for (i=0; i<5; i++)

                {

                ispArray[i] = new ( ELeave ) CArrayFixFlat<TUint32[3]>( 10 );

                CleanupStack::PushL( ispArray[i] );

                }

            if ( isptables[KDIALOUT] )

                {

                GetIspValuesL( isptables[KDIALOUT], ispArray[KDIALOUT],

                               TPtrC(ISP_TYPE) );

                }

            if ( isptables[KGPRSIN] )

                {