/*

* Copyright (c) 2006 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 WLAN Plugin interface implementation 

*                for WLAN Bearer

*

*/

#include <commdb.h>

#include <ecom/ecom.h>		// For REComSession

#include <f32file.h>    // for TParse

#include <StringLoader.h>

#include <data_caging_path_literals.hrh>

#include <ConnectionUiUtilities.h>

#include <cmpluginbaseeng.h>

#include <cmpluginlanbase.h>

#include <mcmdexec.h>

#include <cmpbasesettingsdlg.h>

#include <cmpluginwlan.mbg>

#include <cmwlanui.rsg>

#include <cmmanager.rsg>

#include <cmcommonui.h>

#include <wlancontainer.h>

#include <WEPSecuritySettingsUI.h>

#include <WPASecuritySettingsUI.h>

#include <featmgr.h>

#include <ConeResLoader.h>

#include <AknWaitDialog.h>

#include <uikon/eiksrvui.h>

#include <AknGlobalNote.h>

#include "cmwlancommonconstants.h"

#include "cmpluginwlan.h"

#include "cmwlancoveragecheck.h"

#include "cmlogger.h"

#include "cmpwlansettingsdlg.h"

#include <cmpluginwlandef.h>

#include <cmcommonconstants.h>

#include "cmmanagerimpl.h"

#include "cmpwlanactivewaiter.h"

#include <wifiprotuiinprocess.h>

using namespace CMManager;

#include "wapisecuritysettingsui.h"

// CONSTANTS

const TUint32 KDefaultPriorityWLan = 0;

const TInt KWlanSingleNetwork = 1; // Number of WLAN networks is 1

const TInt KWlanMaxKeyLength = 64;

const TInt KWlanLastSocketActivityTimeout = -1;

const TInt KWlanLastSessionClosedTimeout = 1;

const TInt KWlanLastSocketClosedTimeout = -1;

const TUint32 KEndOfArray = KMaxTUint;

/// Modem bearer names for WLAN connection methods

_LIT( KModemBearerWLAN, "WLANBearer" );

_LIT( KWlanFileIcons, "z:cmpluginwlan.mbm" );

_LIT( KWlanBearerName, "WLANBearer" );

_LIT( KWlanBearerAgent, "wlanagt.agt" );

_LIT( KWlanBearerNif, "wlannif" );

_LIT( KWlanLDDName, "not used" );

_LIT( KWlanPDDName, "not used" );

static const TCmAttribConvTable SWlanConvTbl[] = 

    {

    // iAttribId, iCommsDatId, iValidFuncL, 

    // iTitleId, 

    // iMaxLength, iAttribFlags, iDefValueResId, iEditorResId, iNotUsed1, iNotUsed2

    { EWlanServiceId,           EWlanRangeMax,          NULL },        

    { EWlanServiceId,           KCDTIdWlanServiceId,    NULL },

    { EWlanConnectionMode,      KCDTIdWlanConnMode,     NULL,

      R_QTN_WLAN_SETT_NETWORK_MODE,

       },

    { EWlanSSID,                KCDTIdWlanSSID,         NULL,

      R_QTN_WLAN_SETT_NETWORK_NAME,

      KCmWlanNWNameMaxLength, EConvCompulsory | EConvNoZeroLength, R_QTN_SELEC_SETTING_COMPULSORY, R_TEXT_SETTING_PAGE_NETW_NAME, NULL, NULL },

    { EWlanUsedSSID,            KCDTIdWlanUsedSSID,     NULL },

    { EWlanSecurityMode,        KCDTIdWlanSecMode,      NULL,

      R_QTN_WLAN_SETT_SECURITY_MODE,

      0, 0, 0, 0, NULL, NULL },

    { EWlanAuthenticationMode,  KCDTIdWlanAuthMode,     NULL },

    { EWlanScanSSID,            KCDTIdWlanScanSSID,     NULL,

      R_QTN_WLAN_SETT_HIDDEN_NETWORK,

      0, 0, 0, 0, NULL, NULL },

    { EWlanChannelID,           KCDTIdWlanChannelID,    NULL,

      R_QTN_WLAN_SETT_ADHOC_CHANNEL,

      KCmAdhocChannelMaxLength, EConvNumber, R_QTN_WLAN_SETT_ADHOC_CHANNEL_AUTOMATIC, 0, NULL, NULL },   

    { EWlanAllowSSIDRoaming,  KCDTIdWlanAllowSSIDRoaming,     NULL, 

      R_QTN_WLAN_SETT_SSID_ROAMING,

      0, 0, 0, 0, NULL, NULL },

    { 0,0 }

    };

static const TCmCommonAttrConvArrayItem SCommonConvTbl[] =

{

    { EWlanIfNetworks, ECmIFNetworks },

    { EWlanIpNetMask, ECmIPNetmask },

    { EWlanIpGateway, ECmIPGateway },

    { EWlanIpAddrFromServer, ECmIPAddFromServer },

    { EWlanIpAddr, ECmIPAddress },

    { EWlanIpDNSAddrFromServer, ECmIPDNSAddrFromServer },

    { EWlanIpNameServer1, ECmIPNameServer1 },

    { EWlanIpNameServer2, ECmIPNameServer2 },

    { EWlanIp6DNSAddrFromServer, ECmIP6DNSAddrFromServer },

    { EWlanIp6NameServer1, ECmIP6NameServer1 },

    { EWlanIp6NameServer2, ECmIP6NameServer2 },

    { EWlanIpAddrLeaseValidFrom, ECmIPAddrLeaseValidFrom },

    { EWlanIpAddrLeaseValidTo, ECmIPAddrLeaseValidTo },

    { EWlanConfigDaemonManagerName, ECmConfigDaemonManagerName },

    { EWlanConfigDaemonName, ECmConfigDaemonName },

    { 0, 0 }

    };

/**

 * struct for security mode conversion table

 */

typedef struct

    {

    TUint32 iSecurityMode;

    TUint32 iNWModeSelectionDlgIndex;

    TUint32 iRBSettingPageIndex;

    TUint32 iResId;

    } TCmSecurityModeConvTable;

/**

 * Conversion table for the correct positioning of WLAN security types 

 * in WLAN UI components

 */  

const TCmSecurityModeConvTable KWlanSecurityModeConvTable[] =

    {                              

        { EWlanSecModeOpen,   0, 0, R_QTN_NETW_CONSET_WLAN_SECURITY_MODE_OPEN   },

        { EWlanSecModeWep,    1, 1, R_QTN_NETW_CONSET_WLAN_SECURITY_MODE_WEP    },

        { EWlanSecMode802_1x, 2, 2, R_QTN_NETW_CONSET_WLAN_SECURITY_MODE_802_1X },

        { EWlanSecModeWpa,    3, 3, R_QTN_NETW_CONSET_WLAN_SECURITY_MODE_WPA    },

     // { EWlanSecModeWpa2,   3, 3, R_QTN_NETW_CONSET_WLAN_SECURITY_MODE_WPA2   },

        { EWlanSecModeWAPI,   4, 4, R_QTN_WLAN_SETT_SECURITY_MODE_WAPI   },

        { KEndOfArray, KEndOfArray, KEndOfArray, KEndOfArray }

    };

/**

 * struct for the network mode conversion table

 */

typedef struct

    {

    TUint32 iNwMode;

    TBool   iHidden;

    TUint32 iResId;

    } TCmNetworkModeConvTable;

/**

 * Conversion table for the correct positioning of WLAN network modes

 */

const TCmNetworkModeConvTable KWlanNetworkModeConvTable[] =

    {

        { EInfra, EFalse, R_QTN_WLAN_NETWORK_MODE_INFRA_PUBLIC }, // Infrastructure (public)

        { EInfra, ETrue,  R_QTN_WLAN_NETWORK_MODE_INFRA_HIDDEN }, // Infrastructure (hidden)

        { EAdhoc, EFalse, R_QTN_WLAN_NETWORK_MODE_ADHOC_PUBLIC }, // Ad-hoc (public)

//        { EAdhoc, ETrue,  R_QTN_WLAN_NETWORK_MODE_ADHOC_HIDDEN }, // Ad-hoc (hidden)

        { KEndOfArray, EFalse, KEndOfArray }

    };

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

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

// CCmPluginWlan::NewL

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

//

CCmPluginWlan* CCmPluginWlan::NewL( TCmPluginInitParam* aInitParam )

    {

    if ( !FeatureSupported( KFeatureIdProtocolWlan ) )

        {

        User::Leave( KErrNotSupported );

        }

    CCmPluginWlan* self = new( ELeave ) CCmPluginWlan( aInitParam );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CCmPluginWlan::~CCmPluginWlan

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

//

CCmPluginWlan::~CCmPluginWlan()

    {

    AdditionalReset();

    DestroyWaitDialog();

    RemoveResourceFile( KPluginWlanResDirAndFileName );    

    delete iConnUiUtils; iConnUiUtils = NULL;

    iAdditionalCmsCreated.Close();

    CLOG_CLOSE;

    }

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

// CCmPluginWlan::CreateInstanceL

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

//

CCmPluginBaseEng* CCmPluginWlan::CreateInstanceL( TCmPluginInitParam& aInitParam ) const

    {

    CCmPluginWlan* self = new( ELeave ) CCmPluginWlan( &aInitParam );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CCmPluginWlan::CCmPluginWlan

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

//

CCmPluginWlan::CCmPluginWlan( TCmPluginInitParam* aInitParam )

    : CCmPluginLanBase( aInitParam )

    {

    CLOG_CREATE;

    iWlanTableId = 0;

    iBearerType = KUidWlanBearerType;

    }

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

// CCmPluginWlan::ConstructL

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

//

void CCmPluginWlan::ConstructL()

    {

    LOGGER_ENTERFN( "CCmPluginWlan::ConstructL" );

    CCmPluginLanBase::ConstructL();

    iBearerRecName = KModemBearerWLAN;

    // get WLAN table id

    TRAP_IGNORE( iWlanTableId = CCDWlanServiceRecord::TableIdL( Session() ) );

    if( !iWlanTableId )

        {

        iWlanTableId = CCDWlanServiceRecord::CreateTableL( Session() );

        TMDBElementId tableId = 0;

        TRAP_IGNORE( tableId = CCDWlanDeviceSettingsRecord::TableIdL( Session() ) );

        if( !tableId )

            {

            CCDWlanDeviceSettingsRecord::CreateTableL( Session() );

            }

        TRAP_IGNORE( tableId = CCDWLANSecSSIDTable::TableIdL( Session() ) );

        if( !tableId )

            {

            CCDWLANSecSSIDTable::CreateTableL( Session() );

            }

        TRAP_IGNORE( tableId = CCDDestNWTable::TableIdL( Session() ) );

        if( !tableId )

            {

            CCDDestNWTable::CreateTableL( Session() );

            }

        }

    AddResourceFileL( KPluginWlanResDirAndFileName );

    AddConverstionTableL( ( CCDRecordBase** )&iWlanServiceRecord, 

                            NULL, 

                            SWlanConvTbl );

    AddCommonConversionTableL( SCommonConvTbl );

    iIsWAPISupported = FeatureManager::FeatureSupported( KFeatureIdFfWlanWapi );

    }

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

// CCmPluginWlan::GetIntAttributeL

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

//

TUint32 CCmPluginWlan::GetIntAttributeL( const TUint32 aAttribute ) const

    {

    LOGGER_ENTERFN( "CCmPluginWlan::GetIntAttributeL" );

    TInt retval;

    switch ( aAttribute )

        {

        case ECmExtensionLevel:

            {

    	    retval = CCmPluginLanBase::GetIntAttributeL( aAttribute );

    	    retval++;

            break;

            }        

        case ECmBearerIcon:

            {

            TAknsItemID id;

            MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance();

            TParse mbmFile;

            User::LeaveIfError( mbmFile.Set( KWlanFileIcons, 

                                &KDC_BITMAP_DIR,

                                NULL ) );

            // default - WLAN icon

            TInt icon = EMbmCmpluginwlanQgn_prop_wlan_bearer;

            TInt mask = EMbmCmpluginwlanQgn_prop_wlan_bearer_mask;

            // Easy WLAN icon

            TUint32 easyWlanId = iCmMgr.EasyWlanIdL();

            if ( easyWlanId && GetIntAttributeL( ECmId ) == easyWlanId )

                {

                icon = EMbmCmpluginwlanQgn_prop_set_conn_wlan_easy;

                mask = EMbmCmpluginwlanQgn_prop_set_conn_wlan_easy_mask;

                }

            retval = (TUint32)AknsUtils::CreateGulIconL( 

                                skinInstance, 

                                id,

                                mbmFile.FullName(), 

                                icon, 

                                mask );

            break;

            }  

        case ECmBearerAvailableIcon:

            {

            TAknsItemID id;

            MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance();

            TParse mbmFile;

            User::LeaveIfError( mbmFile.Set( KWlanFileIcons, 

                                &KDC_BITMAP_DIR,

                                NULL ) );

            retval = (TUint32)AknsUtils::CreateGulIconL( 

                                skinInstance, 

                                id,

                                mbmFile.FullName(), 

                                EMbmCmpluginwlanQgn_prop_set_conn_bearer_avail_wlan, 

                                EMbmCmpluginwlanQgn_prop_set_conn_bearer_avail_wlan_mask );

            break;

            }

        case ECmCommsDBBearerType:

            {

            retval = KCommDbBearerWLAN;

            break;

            }

        case ECmDefaultUiPriority:

            {

            retval = GlobalUiBearerPriority( TPtrC(KCDTypeNameWLANServiceExt) );

            if( retval == KDataMobilitySelectionPolicyPriorityWildCard )

                {

                retval = KDefaultPriorityWLan;

                }

            }

            break;

        case ECmDefaultPriority:

            {

            retval = GlobalBearerPriority( TPtrC(KCDTypeNameWLANServiceExt) );

            if( retval == KDataMobilitySelectionPolicyPriorityWildCard )

                {

                retval = KDefaultPriorityWLan;

                }

            }

            break;

        case EWlanServiceId:

            {

            if ( iWlanServiceRecord )

                {

                retval = iWlanServiceRecord->RecordId();

                break;

                }

            }

        default:

            {

    	    retval = CCmPluginBaseEng::GetIntAttributeL( aAttribute );

            break;

            }

        }

    return retval;

    }

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

// CCmPluginWlan::GetBoolAttributeL

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

//

TBool CCmPluginWlan::GetBoolAttributeL( const TUint32 aAttribute ) const

    {

    LOGGER_ENTERFN( "CCmPluginWlan::GetBoolAttributeL" );

    TBool retval( EFalse );

    switch ( aAttribute )

        {

        case ECmCoverage:

            {

#ifndef __WINS__

            TInt& networks = CONST_CAST( TInt&, iWlanNetworks );

            networks = 0;

            networks = CheckNetworkCoverageL();

            // If there's at least one WLAN network around, then there IS

            // coverage.

            retval = ( networks ? ETrue : EFalse );

#else

            TInt& networks = CONST_CAST( TInt&, iWlanNetworks );

            ////networks = 0;

            ////retval = EFalse;

            networks = 1;

            retval = ETrue;

#endif

            }

            break;

        case ECmAddToAvailableList:

            {

            retval = ETrue;

            }

            break;

        case ECmBearerHasUi:

            {

            retval = ETrue;

            }

            break;

        default:

            {

            retval = CCmPluginBaseEng::GetBoolAttributeL( aAttribute );

            break;

            }

        }

    return retval;

    }

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

// CCmPluginWlan::GetStringAttributeL

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

//

HBufC* CCmPluginWlan::GetStringAttributeL( const TUint32 aAttribute ) const

    {

    LOGGER_ENTERFN( "CCmPluginWlan::GetStringAttributeL" );

	HBufC* retVal = NULL;

	switch( aAttribute )

	    {

	    case ECmBearerAvailableName:

	        {

	        retVal = AllocReadL( R_QTN_NETW_CONSET_BEARER_AVAILABLE_WLAN );

	        }

	        break;

        case ECmBearerAvailableText:

            {

            if ( CEikonEnv::Static() )

                {

                if ( iWlanNetworks == KWlanSingleNetwork )

                    {

                    retVal = AllocReadL( 

                                    R_QTN_NETW_CONSET_ONE_WLAN_NW_AVAILABLE );

                    }

                else

                    {

                    retVal = ReadResourceL( 

                                    R_QTN_NETW_CONSET_MANY_WLAN_NW_AVAILABLE,

                                    iWlanNetworks );

                    }

                }

            else

                {   // ReadResourceL does not work without a valid EikonEnv, so

                    // to have a consistent behaviour when there is one or more

                    // wlan networks for ECmBearerAvailableText, we always 

                    // leave when called without valid EikonEnv

                User::Leave( KErrNotSupported );

                }

            }

            break;

	    case ECmBearerSupportedName:

	        {

	        retVal = AllocReadL( R_QTN_NETW_CONSET_BEARER_SUPPORTED_WLAN );

	        }

	        break;

	    case ECmBearerNamePopupNote:

	        {

	        retVal = AllocReadL( R_QTN_NETW_CONSET_POPUP_BEARER_WLAN );

	        }

	        break;

	    case ECmBearerSettingName:

	        {

	        retVal = AllocReadL( R_QTN_WLAN_SETT_BEARER_WLAN );

	        }

	        break;

	    default:

	        {

	        retVal = CCmPluginBaseEng::GetStringAttributeL( aAttribute );