/*

* 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:  Implementation of CApSettingsModel.

*

*/

// INCLUDE FILES

#include "APSettingsHandlerUIVariant.hrh"

#include <ActiveApDb.h>

#include <ApListItemList.h>

#include <ApListItem.h>

#include <ApSelect.h>

#include <apsetui.rsg>

#include <VpnApEngine.h>

#include <hlplch.h>

#include <eikenv.h>

#include <eikappui.h>

#include <StringLoader.h>

#include <featmgr.h>

#include "ApSettingsHandlerUI.hrh"

#include "ApSettingsModel.h"

#include <ApSettingsHandlerCommons.h>

#include "Apsettingsdeleteoperation.h"

#include <sysutil.h>

#include <ErrorUI.h>

#include "ApNetworks.h"

#include "FeatureManagerWrapper.h"

#include <ApAccessPointItem.h>

#include "ApSettingsHandlerLogger.h"

//#define __TEST_PERFORMANCE

// CONSTANTS

/**

* Estimated number of bytes in FFS for one writing operation. This amount

* is checked to be available before each transaction which places write-lock.

* Exact size is not known (because what happens in a transaction is unknown).

* A typical access point is estimated to be less than ~2000 bytes; 

* so assuming the typical operation of adding one access point 

* (with database transaction overhead and safety) is estimated 

* to be 2000 bytes. This should be a safe guess.

*/

LOCAL_C const TInt KEstimatedFfsUsage = 2000;

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

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

// CApSettingsModel::NewL

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

//

CApSettingsModel* CApSettingsModel::NewL( TInt aIspFilter, TInt aBearerFilter,

                                          TInt aSortType, TInt aReqIpvType,

                                          TVpnFilterType aVpnFilterType,

                                          TInt aVariant,

                                          TBool aIncludeEasyWlan,

                                          TBool aNoEdit )

    {

    APSETUILOGGER_ENTERFN( EModel,"Model::NewL")    

    CApSettingsModel* db = 

        new( ELeave ) CApSettingsModel( aIspFilter, aBearerFilter, 

                                        aSortType, aReqIpvType, aVariant,

                                        aVpnFilterType, aIncludeEasyWlan,

                                        aNoEdit );

    CleanupStack::PushL( db );

    db->ConstructL( NULL );

    CleanupStack::Pop(); // db

    APSETUILOGGER_LEAVEFN( EModel,"Model::NewL")    

    return db;

    }

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

// CApSettingsModel::NewL

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

//

CApSettingsModel* CApSettingsModel::NewL( CActiveApDb& aDb, TInt aIspFilter,

                                          TInt aBearerFilter, TInt aSortType,

                                          TInt aReqIpvType, 

                                          TVpnFilterType aVpnFilterType,

                                          TInt aVariant,

                                          TBool aIncludeEasyWlan,

                                          TBool aNoEdit )

    {

    APSETUILOGGER_ENTERFN( EModel,"Model::NewL2")

    CApSettingsModel* db = 

        new( ELeave ) CApSettingsModel( aIspFilter, aBearerFilter, 

                                        aSortType, aReqIpvType, aVariant,

                                        aVpnFilterType, aIncludeEasyWlan,

                                        aNoEdit );

    CleanupStack::PushL( db );

    db->ConstructL( &aDb );

    CleanupStack::Pop(); // db

    APSETUILOGGER_LEAVEFN( EModel,"Model::NewL2")    

    return db;

    }

/**

* Destructor.

*/

CApSettingsModel::~CApSettingsModel( )

    {

    APSETUILOGGER_ENTERFN( EModel,"~Model")

    delete iFeatureManagerWrapper;

    delete iApData;

    delete iUtils;

    delete iVpnApEngine;

    if ( iDbOwned )

        {

        delete iDb;

        }

    if (iop)

        {

        delete iop;

        }

    APSETUILOGGER_LEAVEFN( EModel,"~Model")    

    }

/**

* Constructor

*/

CApSettingsModel::CApSettingsModel( TInt aIspFilter, TInt aBearerFilter, 

                                    TInt aSortType, TInt aReqIpvType,

                                    TInt aVariant,

                                    TVpnFilterType aVpnFilterType,

                                    TBool aIncludeEasyWlan,

                                    TBool aNoEdit )

    {

    APSETUILOGGER_ENTERFN( EModel,"Model")

    iWepUiExitReason = 0;

    iParams.iIspFilter = aIspFilter;

    iParams.iBearerFilter = aBearerFilter;

    iParams.iSortType = aSortType;

    iReqIpvType = aReqIpvType;

    iApData = NULL;

    iDb = NULL;

    iUtils = NULL;

    iDbOwned = ETrue;

    iVpnFilterType = aVpnFilterType;

    iVariant = aVariant;

    iIncludeEasyWlan = aIncludeEasyWlan;

    iNoEdit = aNoEdit;

    iInRefresh = EFalse;

    iNeedRefresh = EFalse;

    APSETUILOGGER_LEAVEFN( EModel,"Model")    

    }

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

// CApSettingsModel::ConstructL

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

//

void CApSettingsModel::ConstructL( CActiveApDb* aDb )

    {

    APSETUILOGGER_ENTERFN( EModel,"Model::ConstructL")

    if ( aDb )

        {

        iDbOwned = EFalse;

        iDb = aDb;

        }

    else

        {

        iDb = CActiveApDb::NewL( EDatabaseTypeIAP );

        iDbOwned = ETrue;

        }

    iApData = CApDataHandler::NewLC( *iDb->Database() );

    CleanupStack::Pop( iApData ); // as it is a member

    iUtils = CApUtils::NewLC( *iDb->Database() );

    CleanupStack::Pop( iUtils ); //

    iVpnApEngine = CVpnApEngine::NewLC( iDb->Database() );

    CleanupStack::Pop( iVpnApEngine ); //

    iFeatureManagerWrapper = CFeatureManagerWrapper::NewL();

    iHelpSupported = FeatureManager::FeatureSupported( KFeatureIdHelp );

    iProtectionSupported = FeatureManager::FeatureSupported( 

                                            KFeatureIdSettingsProtection );

    APSETUILOGGER_LEAVEFN( EModel,"Model::ConstructL")    

    }

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

// CApSettingsModel::Database

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

//

CActiveApDb* CApSettingsModel::Database()

    {

    APSETUILOGGER_ENTERFN( EModel,"Model::Database<->")

    return iDb;

    }

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

// CApSettingsModel::AllListItemDataL

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

//

TInt CApSettingsModel::AllListItemDataL( TBool& aFailedLocked, 

                                         CApListItemList& aList, 

                                         TInt aIspFilter, TInt aBearerFilter,

                                         TInt aSortType, TInt aReqIpvType )

    {

    APSETUILOGGER_ENTERFN( EModel,"Model::AllListItemDataL<->")

    return AllListItemDataL( aFailedLocked, aList, aIspFilter, 

                             aBearerFilter, aSortType, aReqIpvType,

                             iVpnFilterType, iIncludeEasyWlan );

    }

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

// CApSettingsModel::AllListItemDataL

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

//

TInt CApSettingsModel::AllListItemDataL( 

                                        TBool& aFailedLocked,

                                        CApListItemList& aList,

                                        TInt aIspFilter,

                                        TInt aBearerFilter,

                                        TInt aSortType,

                                        TInt aReqIpvType,

                                        TVpnFilterType aVpnFilterType,

                                        TBool aIncludeEasyWlan

                                        )

    {

    APSETUILOGGER_ENTERFN( EModel,"Model::AllListItemDataL2")

    TInt retval( 0 );

    if (iInRefresh)

        {

        APSETUILOGGER_WRITE( EModel,"AllListItemData overrun->");

        iNeedRefresh = ETrue;

        }

    else

        {

        iInRefresh = ETrue;

        aFailedLocked = EFalse;

        CApSelect* apselect = CApSelect::NewLC( *iDb->Database(), aIspFilter, 

                                                aBearerFilter, aSortType,

                                                aReqIpvType,

                                                aVpnFilterType,

                                                aIncludeEasyWlan );

        APSETUILOGGER_WRITE( EModel,"ApSelect::NewLC returned");

        retval = apselect->AllListItemDataL( aList );

        APSETUILOGGER_WRITE( EModel,"ApSelect::AllListItemDataL returned");

        CleanupStack::PopAndDestroy( apselect ); // apselect

        retval = aList.Count();

        iInRefresh = EFalse;

        }

    if (iNeedRefresh && !iInRefresh)

        {

        APSETUILOGGER_WRITE( EModel,"add. refresh starts");

        retval = AllListItemDataL( aFailedLocked, aList, aIspFilter, 

                                   aBearerFilter, aSortType, aReqIpvType,

                                   aVpnFilterType, aIncludeEasyWlan );

        iNeedRefresh = EFalse;

        APSETUILOGGER_WRITE( EModel,"add. refresh ends");

        }

    APSETUILOGGER_LEAVEFN( EModel,"Model::AllListItemDataL2")

    return retval;

    }

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

// CApSettingsModel::AllListItemDataL

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

//

TInt CApSettingsModel::AllListItemDataL( TBool& aFailedLocked, 

                                         CApListItemList& aList )

    {

    APSETUILOGGER_ENTERFN( EModel,"Model::AllListItemDataL ->")

    return AllListItemDataL( aFailedLocked, aList,  iParams.iIspFilter, 

                                                iParams.iBearerFilter, 

                                                iParams.iSortType,

                                                iReqIpvType, iVpnFilterType,

                                                iIncludeEasyWlan );

    }

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

// CApSettingsModel::AccessPointDataL

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

//

void CApSettingsModel::AccessPointDataL( TUint32 aUid, 

                                         CApAccessPointItem& aApItem )

    {

    APSETUILOGGER_ENTERFN( EModel,"Model::AccessPointDataL")

    TTransactionResult ownTransaction = StartTransactionLC( /*aWrite*/EFalse,

                                               /*aShowNote*/ETrue,

                                               /*aRetry*/ETrue );

    if ( ownTransaction != EFailedWithLocked )

        {

        iApData->AccessPointDataL( aUid, aApItem );    // adds normal ap

        // Load wlan data, only loads if WLAN ap.

        TRAPD( err, LoadWlanL( aApItem ) );

        if ( err != KErrUnknown)

            {

            User::LeaveIfError( err );

            }

        if ( ownTransaction == EOwnTransaction )

            {

            TInt err = CommitTransaction();

            User::LeaveIfError( err );

            CleanupStack::Pop(); // RollbackTransactionOnLeave

            }

        }

    APSETUILOGGER_LEAVEFN( EModel,"Model::AccessPointDataL")    

    }

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

// CApSettingsModel::UpdateAccessPointDataL

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

//

TBool CApSettingsModel::UpdateAccessPointDataL( CApAccessPointItem& aApItem )

    {

    APSETUILOGGER_ENTERFN( EModel,"Model::UpdateAccessPointDataL")

    TBool nameChanged( EFalse );

// It should be aWrite ETrue, but there is an error in Symbian stuff

// causing a memory leak

//    TTransactionResult ownTransaction = StartTransactionLC( /*aWrite*/ETrue,

    TTransactionResult ownTransaction = StartTransactionLC( /*aWrite*/EFalse,

                                               /*aShowNote*/ETrue,

                                               /*aRetry*/ETrue );

    if ( ownTransaction != EFailedWithLocked )

        {

        TBool isnew(EFalse);

        if ( aApItem.BearerTypeL() == EApBearerTypeWLAN )

            { // it is WLAN...

            // check that there were no bearer-change, because if orig. bearer

            // was NOT wlan, then we shouls consider it as a new record!!!

            if ( iUtils->BearerTypeL( aApItem.WapUid() ) != EApBearerTypeWLAN )

                {

                isnew = ETrue;

                }

            }

        iApData->UpdateAccessPointDataL( aApItem, nameChanged );

        // write wlan data, only writes if WLAN ap.

        WriteWlanL( aApItem, isnew );

#ifdef __WINS__

        ShowNoteL( R_APUI_VIEW_SAVED );

#endif

        if ( ownTransaction == EOwnTransaction )

            {

            TInt err = CommitTransaction();

            User::LeaveIfError( err );

            CleanupStack::Pop(); // RollbackTransactionOnLeave

            }

        }

    APSETUILOGGER_LEAVEFN( EModel,"Model::UpdateAccessPointDataL")

    return nameChanged;

    }

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

// CApSettingsModel::DataHandler

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

//

CApDataHandler* CApSettingsModel::DataHandler()

    {

    APSETUILOGGER_ENTERFN( EModel,"Model::DataHandler <->")

    return iApData;

    }

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

// CApSettingsModel::ApUtils

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

//

CApUtils* CApSettingsModel::ApUtils()

    {

    APSETUILOGGER_ENTERFN( EModel,"Model::ApUtils <->")

    return iUtils;

    }

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

// CApSettingsModel::SetParams

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

//

void CApSettingsModel::SetParams( TApSettingsParams aParams )

    {

    APSETUILOGGER_ENTERFN( EModel,"Model::SetParams <->")

    iParams = aParams;

    }

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

// CApSettingsModel::Params

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

//

TApSettingsParams CApSettingsModel::Params()

    {

    APSETUILOGGER_ENTERFN( EModel,"Model::Params <->")

    return iParams;

    }

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

// CApSettingsModel::VpnEngine

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

//

CVpnApEngine* CApSettingsModel::VpnEngine()

    {

    APSETUILOGGER_ENTERFN( EModel,"Model::VpnEngine <->")

    return iVpnApEngine;

    }

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

// CApSettingsModel::LaunchHelpL

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

//

void CApSettingsModel::LaunchHelpL()

    {

#ifdef __SERIES60_HELP

    APSETUILOGGER_ENTERFN( EModel,"Model::LaunchHelpL")

    HlpLauncher::LaunchHelpApplicationL(

                        EikEnv()->WsSession(),

                        EikEnv()->EikAppUi()->AppHelpContextL() );

    APSETUILOGGER_LEAVEFN( EModel,"Model::LaunchHelpL")    

#endif // __SERIES60_HELP

    }

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

// CApSettingsModel::RemoveApL

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

//

void CApSettingsModel::RemoveApL( TUint32 aUid )

    {

    APSETUILOGGER_ENTERFN( EModel,"Model::RemoveApL")

// DELETE OPERATION STARTS HERE

    TBuf<KModifiableTextLength> sgd;

    iUtils->NameL( aUid, sgd );

    HBufC* temp = StringLoader::LoadLC( R_APUI_VIEW_DELETING_AP, sgd );    

    APSETUILOGGER_WRITE( EModel,"Creating thread");

    if (!iop)

        {

        iop = CApSettingsDeleteOperation::NewL(

                        KApWaitNote, R_APUI_VIEW_WAIT_NOTE,

                        aUid, *temp

                        );

        APSETUILOGGER_WRITE( EModel,"Thread created");

        }

    else

        {

        if (iop->State() != CApSettingsDeleteOperation::EProcOffDialogOff )

            {

            ShowNoteL( R_APUI_VIEW_TEXT_CANNOT_ACCESS_DB );

            User::Leave( KErrInUse );

            }

        else

            {

            iop->SetUid( aUid );

            iop->SetNoteTextL( *temp );

            }

        }

    TRAPD(err, iop->StartL() );

    APSETUILOGGER_WRITE_FORMAT( EModel, "Thread StartL returned, code:%d", err);

    if ( err != KErrNone )

        { 

        User::Leave( err );

        }

    CleanupStack::PopAndDestroy( temp );

    APSETUILOGGER_LEAVEFN( EModel,"Model::RemoveApL")    

// DELETE OPERATION ENDS HERE

    }