/*

* 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 plugins (base & all derived).

*

*/

// INCLUDE FILES

#include "ActiveSelectConnectionPlugin.h"

#include "SelectConnectionDialog.h"

#include "ConnectionDialogsLogger.h"

#include "ConnectionInfo.h"

#include "ConnectionInfoArray.h"

#include "sortsnaputils.h"

#include "cdbcols.h"

#include <featmgr.h>

#include <StringLoader.h>

#include <AknIconArray.h>

#include <AknsUtils.h>

#include <AknIconUtils.h>

#include <data_caging_path_literals.hrh>

#include <cmdestinationext.h>

#include <cmconnectionmethoddef.h>

#include <cmpluginwlandef.h>

#include <cmmanager.mbg>

#include <CConnDlgPlugin.rsg>

#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <commsdat.h>

#else

#include <commsdat.h>

#include <commsdat_partner.h>

#endif

#include <wlancontainer.h>

#include <metadatabase.h>

// CONSTANTS

// Category for all panics in this module

_LIT( KASCPCategory, "Select Connection Plugin" );

LOCAL_D const TInt KIconsGranularity = 4;

LOCAL_D const TInt KArrayGranularity = 4;

LOCAL_D const TInt KMaxEntryLength = CommsDat::KMaxTextLength*2 + 20;

/**

* For iPeriodic Timer, 60 seconds

*/

LOCAL_C const TInt KTickDefaultInterval = 60000000;

LOCAL_C const TInt KMicrosecondsToSecondsMultiplier = 1000000;

// background scan automatic scanning value

static const TUint KWlanBgScanIntervalAuto = 0xffffffff;

using namespace CMManager;

///////////////////////////////////////////////////////////////////////////////

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

// CActiveSelectConnectionPlugin::CActiveSelectConnectionPlugin()

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

//

CActiveSelectConnectionPlugin::CActiveSelectConnectionPlugin( 

                                                MEikSrvNotifierBase2* aPlugin,

                                                const TUint32 aElementId,

                                                TUint32 aBearerSet )

: iBearerSet( aBearerSet ),

  iReqBearerSet( aBearerSet ),

  iElementId( aElementId ),

  iPlugin( aPlugin ), 

  iDialogConn( NULL ),

  iIsWLANFeatureSupported( EFalse ),

  iRefreshInterval( KTickDefaultInterval ),

  iHighlightedItem( -1 ),

  iDefaultDestId( 0 ),

  iDefaultCMId( 0 )

    {

    }

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

// CActiveSelectConnectionPlugin* CActiveSelectConnectionPlugin::NewL()

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

//

CActiveSelectConnectionPlugin* CActiveSelectConnectionPlugin::NewL( 

                                                MEikSrvNotifierBase2* aPlugin,

                                                const TUint32 aElementId,

                                                TUint32 aBearerSet )

    {

    CLOG_ENTERFN( "CActiveSelectConnectionPlugin::NewL " );  

    CActiveSelectConnectionPlugin* self = new ( ELeave ) 

                CActiveSelectConnectionPlugin( aPlugin, aElementId, 

                                               aBearerSet );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    CLOG_LEAVEFN( "CActiveSelectConnectionPlugin::NewL " );      

    return self;        

    }

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

// CActiveSelectConnectionPlugin::ConstructL()

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

//

void CActiveSelectConnectionPlugin::ConstructL()

    {

    CLOG_ENTERFN( "CActiveSelectConnectionPlugin::ConstructL " );  

    CActiveBase::ConstructL();

    FeatureManager::InitializeLibL();

    iIsWLANFeatureSupported = FeatureManager::FeatureSupported( 

                                                KFeatureIdProtocolWlan );

    FeatureManager::UnInitializeLib();

    iBearerSet |= ECommDbBearerVirtual;    // To get also VPN APs

#ifdef __WINS__

    iBearerSet |= ECommDbBearerLAN;     // To add Ethernet AP

#endif  // __WINS__

    if ( iIsWLANFeatureSupported )

        {

        CLOG_WRITE( "WLAN Supported!" );        

        iBearerSet |= ECommDbBearerWLAN; // To add WLan AP

        iRefreshInterval = GetRefreshIntervalL();

        }

    iItems = new( ELeave ) CConnectionInfoArray();

    iIcons = new( ELeave ) CAknIconArray( KIconsGranularity );

    iCmManagerExt.OpenL();

    TInt ret = iMPM.LaunchServer();

    if ( ret != KErrAlreadyExists )

        {

        User::LeaveIfError( ret );

        }

    CLOG_LEAVEFN( "CActiveSelectConnectionPlugin::ConstructL " );  

    }

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

// CActiveSelectConnectionPlugin::~CActiveSelectConnectionPlugin()

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

//    

CActiveSelectConnectionPlugin::~CActiveSelectConnectionPlugin()

    {

    CLOG_ENTERFN( "~CActiveSelectConnectionPlugin" );

    Cancel();

    if ( iItems )

        {

        iItems->ResetAndDestroy();

        }

    delete iItems;    

    iItems = NULL;

    iCmManagerExt.Close();

    iMPM.Close();

    CLOG_LEAVEFN( "~CActiveSelectConnectionPlugin" );

    }

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

// CActiveSelectConnectionPlugin::Cancel()

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

// 

void CActiveSelectConnectionPlugin::Cancel()

    {

    StopTimer();

    CActive::Cancel();

    if( iDialogConn && !( iDialogConn->GetOkToExit() ) )

        {

        CLOG_WRITEF( _L( "iDialogConn->GetOkToExit() : %b" ), iDialogConn->GetOkToExit() );

        delete iDialogConn;

        iDialogConn = NULL;

        }

    }

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

// CActiveSelectConnectionPlugin::DoCancel()

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

// 

void CActiveSelectConnectionPlugin::DoCancel()

    {

    }

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

// CActiveSelectConnectionPlugin::RunL()

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

//     

void CActiveSelectConnectionPlugin::RunL()

    {

    CLOG_ENTERFN( "CActiveSelectConnectionPlugin::RunL " );  

    if( iStatus == KErrNone )

        {

        BuildConnectionListL();

        iDialogConn->RefreshDialogL( iItems, iIcons, ETrue, iHighlightedItem );

        }     

    CLOG_LEAVEFN( "CActiveSelectConnectionPlugin::RunL " );      

    }

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

// CActiveSelectConnectionPlugin::ShowSelectConnectionL()

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

//    

void CActiveSelectConnectionPlugin::ShowSelectConnectionL()

    {    

    CLOG_ENTERFN( "CActiveSelectConnectionPlugin::ShowSelectConnectionL" );

    BuildConnectionListL();

    iDialogConn = CSelectConnectionDialog::NewL( iPlugin, iRefreshInterval,

                                                 iBearerSet, 

                                                 iIsWLANFeatureSupported, 

                                                 iDefaultCMId );

    iDialogConn->PrepareAndRunLD( iItems, iIcons, EFalse, iHighlightedItem );

    if( iRefreshInterval )

        {

        StartTimerL( iRefreshInterval );

        }     

    CLOG_LEAVEFN( "CActiveSelectConnectionPlugin::ShowSelectConnectionL" );

    }

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

// CActiveSelectConnectionPlugin::BuildConnectionListL()

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

//

void CActiveSelectConnectionPlugin::BuildConnectionListL()

    {

    CLOG_ENTERFN( "CActiveSelectConnectionPlugin::BuildConnectionListL " );  

    // iItems and iIcons are allocated at construction and deallocated at 

    // destruction. Unless memory allocation has failed, they cannot be NULL.

    __ASSERT_ALWAYS( iItems, User::Panic( KASCPCategory, KErrGeneral ) );

    __ASSERT_ALWAYS( iIcons, User::Panic( KASCPCategory, KErrGeneral ) );

    iItems->ResetAndDestroy();

    iIcons->ResetAndDestroy();

    _LIT( KDriveZ, "z:" );  // ROM folder

    // Name of the MBM file containing icons

    _LIT( KManagerIconFilename, "cmmanager.mbm" );

    TFileName iconsFileName;

    iconsFileName.Append( KDriveZ );

    iconsFileName.Append( KDC_APP_BITMAP_DIR );

    iconsFileName.Append( KManagerIconFilename );

//    iIcons->AppendL( AknsUtils::CreateGulIconL( AknsUtils::SkinInstance(),

//                                KAknsIIDQgnIndiCbHotAdd,

//                                iconsFileName, 

//                                EMbmCmmanagerQgn_indi_cb_hot_add, 

//                                EMbmCmmanagerQgn_indi_cb_hot_add_mask ) );

    // Create color icon for marking the default connection

    //

    CFbsBitmap* bitmap = NULL;

    CFbsBitmap* mask   = NULL;               

    CGulIcon* icon     = CGulIcon::NewLC();

    AknsUtils::CreateColorIconL( AknsUtils::SkinInstance(), 

                    KAknsIIDQgnIndiCbHotAdd, 

                    KAknsIIDQsnIconColors, EAknsCIQsnIconColorsCG13, 

                    bitmap, 

                    mask, 

                    iconsFileName,

                    EMbmCmmanagerQgn_indi_cb_hot_add, 

                    EMbmCmmanagerQgn_indi_cb_hot_add_mask,

                    KRgbBlack );

    icon->SetBitmap( bitmap );

    icon->SetMask( mask );    

    iIcons->AppendL( icon );

    CleanupStack::Pop( icon ); 

    TCmDefConnValue defaultConnSetting;

    iCmManagerExt.ReadDefConnL( defaultConnSetting );

    if ( defaultConnSetting.iType == ECmDefConnDestination )

        {

        iDefaultDestId = defaultConnSetting.iId;

        }

    else if ( defaultConnSetting.iType == ECmDefConnConnectionMethod )

        {

        iDefaultCMId = defaultConnSetting.iId;

        }

    if ( iIsWLANFeatureSupported && (iReqBearerSet & ECommDbBearerWLAN) )

        {

        AddSearchForWLanItemL();

        }

    AddDestinationItemsL();

    CLOG_WRITEF( _L( "iItems count: %d" ), iItems->Count() );

    CLOG_LEAVEFN( "CActiveSelectConnectionPlugin::BuildConnectionListL " );

    }

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

// CActiveSelectConnectionPlugin::AddSearchForWLanItemL

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

//    

void CActiveSelectConnectionPlugin::AddSearchForWLanItemL()

    {

    TUint32 easyWlanId = iCmManagerExt.EasyWlanIdL();

    if ( easyWlanId )

        {

        CLOG_WRITEF( _L( "easyWlanId %d" ), easyWlanId );

        RCmConnectionMethodExt cmConnMethodExt;

        TRAPD( err, cmConnMethodExt = iCmManagerExt.ConnectionMethodL( 

                                                                easyWlanId ) );

        if ( err == KErrNone )

            {

            CleanupClosePushL( cmConnMethodExt );

            CGulIcon* wlanIcon = ( CGulIcon* )

                            cmConnMethodExt.GetIntAttributeL( ECmBearerIcon );

            CleanupStack::PopAndDestroy();  // cmConnMethodExt

            if ( wlanIcon )

                {

                CleanupStack::PushL( wlanIcon );

                iIcons->AppendL( wlanIcon );

                // icon array took over ownership

                CleanupStack::Pop( wlanIcon );

                // +1 because it "Zero terminates" the string

                TBuf<CommsDat::KMaxTextLength+1> nameSearch;

                _LIT( KIconIdNameEmpty, "%d\t%s\t" );

                HBufC *msg = StringLoader::LoadL( R_WLAN_EASY_WLAN );

                nameSearch = *msg;

                nameSearch.ZeroTerminate();

                delete msg;

                TBuf<KMaxEntryLength> temp;

                temp.FillZ( KMaxEntryLength );

                temp.Format( KIconIdNameEmpty, iIcons->Count()-1,

                             nameSearch.Ptr() );

                CConnectionInfo* conIn = CConnectionInfo::NewL( easyWlanId, 

                                                    0, temp );

                CleanupStack::PushL( conIn );

                iItems->AppendL( conIn );

                CleanupStack::Pop( conIn );

                iHighlightedItem = 0;

                }

            }

        }

    }

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

// CActiveSelectConnectionPlugin::AddDestinationItemsL

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

//    

void CActiveSelectConnectionPlugin::AddDestinationItemsL()

    {

 /*   TInt errConnect = iMPM.Connect();

    CLOG_WRITEF( _L( "errConnect = %d" ), errConnect );

    if ( errConnect == KErrNone )

        {*/

        TSortSnapUtils sortSnapUtils( iMPM );

        RArray<TUint32> destIdArray( KArrayGranularity );

        TRAPD( err, sortSnapUtils.GetDestIdArrayL( iCmManagerExt, destIdArray ) );

        //TRAPD( err, iCmManagerExt.AllDestinationsL( destIdArray ) );

        // Append the destinations to the list

        CLOG_WRITEF( _L( "GetDestIdArrayL returned with  %d" ), err );

    if ( err == KErrNone )

            {

            CleanupClosePushL( destIdArray );

            CLOG_WRITEF( _L( "destIdArray.Count() =  %d" ), destIdArray.Count() );

            for ( TInt i = 0; i < destIdArray.Count(); i++ )

                {

                RCmDestinationExt cmDestExt = iCmManagerExt.DestinationL( 

                                                            destIdArray[i] );

                CleanupClosePushL( cmDestExt );

                if ( /*cmDestExt.ElementId() != iElementId &&*/ 

                     !cmDestExt.MetadataL( ESnapMetadataHiddenAgent ) )

                    {

                    CLOG_WRITEF( _L( "Destination id %d, Total number of methods %d" ), 

                                destIdArray[i], cmDestExt.ConnectionMethodCount() );

#ifdef _DEBUG

                    for ( TInt j = 0; 

                            j < cmDestExt.ConnectionMethodCount(); j++ )

                        {

                        RCmConnectionMethodExt cmConnMethodExt;

                        TRAP( err, cmConnMethodExt = 

                                            cmDestExt.ConnectionMethodL( j ) );

                        if ( err == KErrNone )

                            {

                            CleanupClosePushL( cmConnMethodExt );

                            HBufC* bufMethod = 

                                cmConnMethodExt.GetStringAttributeL( ECmName );

                            CleanupStack::PushL( bufMethod );

                            TBuf<CommsDat::KMaxTextLength+1> nameMethod;

                            nameMethod = *bufMethod;

                            nameMethod.ZeroTerminate();

                            /*CLOG_WRITEF( _L( "ConnMethod id %d, Method name %s" ), 

                                cmConnMethodExt.GetIntAttributeL( ECmIapId ),

                                nameMethod.Ptr() );*/

                            CleanupStack::PopAndDestroy( bufMethod );

                            CleanupStack::PopAndDestroy();  // cmConnMethodExt

                            }

                        }

#endif

                        AddDestinationItemL( cmDestExt, destIdArray[i], i == 0,

                                             destIdArray[i] == iDefaultDestId,

                                             sortSnapUtils );

                    }

                CleanupStack::PopAndDestroy();  // cmDestExt

                }

            CleanupStack::PopAndDestroy(); // destIdArray

            }

        AddUncategorizedItemL( sortSnapUtils );

/*        }*/

    }

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

// CActiveSelectConnectionPlugin::AddDestinationItemL

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

//    

void CActiveSelectConnectionPlugin::AddDestinationItemL( 

                                                RCmDestinationExt aDestination,

                                                TUint32 aDestId, 

                                                TBool aFirstItem, 

                                                TBool aDefaultDest,

                                                TSortSnapUtils& aSortSnapUtils )

    {

    TMpmSnapBuffer list;

    TInt errMPM = aSortSnapUtils.GetSortSnapData( aDestId, list );

    CLOG_WRITEF( _L( "errMPM = %d. list.Count() = %d" ), errMPM, list.Count() );

    if ( errMPM == KErrNone )

        {

        for ( TInt numCM = 0; numCM < list.Count(); numCM++ )

            {

            RCmConnectionMethodExt cmConnMethodExt;

            TRAPD( err, cmConnMethodExt = iCmManagerExt.ConnectionMethodL(

                                                        list.iIapId[numCM] ) );

            CLOG_WRITEF( _L( "Trapped err = %d" ), err );

            if ( err == KErrNone )

                {

                CleanupClosePushL( cmConnMethodExt );

                if ( iBearerSet & cmConnMethodExt.GetIntAttributeL( 

                                                    ECmCommsDBBearerType ) )

                    {

                    HBufC* bufBest = cmConnMethodExt.GetStringAttributeL(

                                                                    ECmName );

                    CleanupStack::PopAndDestroy();      // cmConnMethodExt

                    CleanupStack::PushL( bufBest );

                    _LIT( KIconIdNameBest, "%d\t%s\t\"%s\"" );

                    _LIT( KIconIdNameBestDefaultConn, "%d\t%s\t\"%s\"\t0" );

                    TBuf<CommsDat::KMaxTextLength+1> nameBest;

                    nameBest = *bufBest;

                    nameBest.ZeroTerminate();

                    CleanupStack::PopAndDestroy( bufBest );

                    TBuf<CommsDat::KMaxTextLength+1> nameDest;

                    HBufC* name = aDestination.NameLC();

                    nameDest = *name;

                    nameDest.ZeroTerminate();

                    CleanupStack::PopAndDestroy( name );

                    CGulIcon* destIcon = aDestination.IconL();

                    if ( destIcon )

                        {

                        CleanupStack::PushL( destIcon );

                        iIcons->AppendL( destIcon );

                        // icon array took over ownership

                        CleanupStack::Pop( destIcon );

                        TBuf<KMaxEntryLength> temp;

                        temp.FillZ( KMaxEntryLength );

                        if ( aDefaultDest )

                            {