/*

* 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:  Dialog for editing settings for a packet data connection 

*

*/

// INCLUDE FILES

// System

#include <AknsUtils.h>

#include <data_caging_path_literals.hrh>

#include <cmpluginpacketdata.mbg>           // icons

#include <cmpacketdataui.rsg>

#include <AknQueryDialog.h>

#include <StringLoader.h>

#include <cmmanager.rsg>

// User

#include "cmpluginpacketdata.h"

#include <cmpluginpacketdatadef.h>

#include "cmpacketdatacommonconstants.h"

#include "cmlogger.h"

#include "cmppacketdatasettingsdlg.h"

#include <cmpsettingsconsts.h>

#include "datamobilitycommsdattypes.h"

#include <cmcommonconstants.h>

#include <cmmanagerdef.h>

using namespace CMManager;

using namespace CommsDat;

// ================= CONSTANTS =======================

const TUint32 KDefaultPriorityPacketData = 1;

/// Modem bearer names for GPRS/WCDMA Access Points

_LIT( KModemBearerPacketData, "GPRS Modem" );

_LIT( KPacketDataFileIcons, "z:cmpluginpacketdata.mbm" );

_LIT( KDefaultQosDataRecordName, "PRIMARY1" );

_LIT( KDefaultQosDataRecordNamewithSpace, "PRIMARY1 " );

// ================= LOCAL PROTOTYPES =======================

/**

* Function to check and set PDP type and IfNetwork.

* @param aThis 'this' pointer of the plugin instance

* @param aAttribute attribute client wants to set

* @param aValue TInt* IPv4 address buffer to be checked

*/

static TBool SetPDPTypeL( CCmPluginBaseEng* aThis, 

                   TUint32 aAttribute, 

                   const TAny* aValue );

static const TCmAttribConvTable SPacketDataConvTbl[] = 

    {

    // iAttribId, iCommsDatId, iValidFuncL, 

    // iTitleId, 

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

    { EPacketDataAPName, EGPRSReqTrafficClass-1, NULL,

      0,

      0, 0, 0, NULL, NULL },

    { EPacketDataAPName, KCDTIdAPN, NULL,

      R_GPRS_PLUGIN_VIEW_AP_NAME,

      KMaxGprsApNameLength, 0, R_GPRS_PLUGIN_SETT_VAL_FIELD_NONE, R_TEXT_SETTING_PAGE_GPRSAP_NAME, NULL, NULL },

    { EPacketDataPDPType, KCDTIdWCDMPDPType, &SetPDPTypeL,

      R_GPRS_PLUGIN_VIEW_PDP_TYPE,

      0, 0, 0, NULL, NULL },

    { EPacketDataPDPAddress, KCDTIdWCDMAPDPAddress, NULL },

    { EPacketDataReqPrecedence, KCDTIdReqPrecedence, NULL },

    { EPacketDataReqDelay, KCDTIdReqDelay, NULL },

    { EPacketDataReliability, KCDTIdReqReliability, NULL },

    { EPacketDataPeakThroughput, KCDTIdReqPeakThroughput, NULL },

    { EPacketDataMeanThroughput, KCDTIdReqMeanThroughput, NULL },

    { EPacketDataMinPrecedence, KCDTIdMinPrecedence, NULL },

    { EPacketDataMinDelay, KCDTIdMinDelay, NULL },

    { EPacketDataMinReliability, KCDTIdMinReliability, NULL },

    { EPacketDataMinPeakThroughput, KCDTIdMinPeakThroughput, NULL },

    { EPacketDataMinMeanThroughput, KCDTIdMinMeanThroughput, NULL },

    { EPacketDataDataCompression, KCDTIdWCDMADataCompression, NULL },

    { EPacketDataHeaderCompression, KCDTIdWCDMAHeaderCompression, NULL },

    { EPacketDataUseEdge, KCDTIdWCDMAUseEdge, NULL },

    { EPacketDataAnonymousAccess, KCDTIdWCDMAAnonymousAccess, NULL },

    { EPacketDataIFParams, KCDTIdWCDMAIfParams, NULL },

    { EPacketDataIFNetworks, KCDTIdWCDMAIfNetworks, NULL },

    { EPacketDataIFPromptForAuth, KCDTIdWCDMAIfPromptForAuth, NULL,

      R_QTN_SET_PROMPT_PASSWD,

      0, 0, 0, NULL, NULL },

    { EPacketDataIFAuthName, KCDTIdWCDMAIfAuthName, NULL,

      R_QTN_SET_AP_USERNAME,

      KMaxLoginNameLength, 0, R_QTN_SET_AP_USERNAME_NONE, R_TEXT_SETTING_PAGE_LOGIN_NAME, NULL, NULL },

    { EPacketDataIFAuthPass, KCDTIdWCDMAIfAuthPass, NULL,

      R_QTN_SET_AP_PASSWD,

      KCmMaxPasswordLength, EConvPassword, R_AVKON_NUMERIC_PASSWORD_BLANKING_TEXT, NULL, NULL },

    { EPacketDataIFAuthRetries, KCDTIdWCDMAIfAuthRetries, NULL },

    { EPacketDataIPNetmask, KCDTIdWCDMAIPNetMask, &CheckIPv4ValidityL },

    { EPacketDataIPGateway, KCDTIdWCDMAIPGateway, &CheckIPv4ValidityL },

    { EPacketDataIPAddrFromServer, KCDTIdWCDMAIPAddrFromServer, NULL },

    { EPacketDataIPAddr, KCDTIdWCDMAIPAddr, &CheckIPv4ValidityL,

      R_QTN_SET_IP_ADDRESS,

      KIpAddressWidth, EConvIPv4, R_QTN_SET_IP_ADDRESS_DYNAMIC, 0, NULL, NULL },

    { EPacketDataIPDNSAddrFromServer, KCDTIdWCDMAIPDNSAddrFromServer, NULL,

      R_QTN_SET_DNS_SERVERS_IP,

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

    { EPacketDataIPNameServer1, KCDTIdWCDMAIPNameServer1, &CheckIPv4ValidityL,

      R_QTN_SET_PRIMARY_DNS,

      KMaxIPv4NameServerLength, EConvIPv4, R_QTN_SET_DNS_SERVERS_AUTOMATIC, 0, NULL, NULL },

    { EPacketDataIPNameServer2, KCDTIdWCDMAIPNameServer2, &CheckIPv4ValidityL,

      R_QTN_SET_SECONDARY_DNS,

      KMaxIPv4NameServerLength, EConvIPv4, R_QTN_SET_DNS_SERVERS_AUTOMATIC, 0, NULL, NULL },

    { EPacketDataIPIP6DNSAddrFromServer, KCDTIdWCDMAIP6DNSAddrFromServer, NULL,

      R_QTN_SET_DNS_SERVERS_IP,

      0, 0, 0, NULL, NULL },

    { EPacketDataIPIP6NameServer1, KCDTIdWCDMAIP6NameServer1, &CheckIPv6ValidityL },

    { EPacketDataIPIP6NameServer2, KCDTIdWCDMAIP6NameServer2, &CheckIPv6ValidityL },

    { EPacketDataIPAddrLeaseValidFrom, KCDTIdWCDMAIPAddrLeaseValidFrom, NULL },

    { EPacketDataIPAddrLeaseValidTo, KCDTIdWCDMAIPAddrLeaseValidTo, NULL },

    { EPacketDataConfigDaemonManagerName, KCDTIdWCDMAConfigDaemonManagerName, NULL },

    { EPacketDataConfigDaemonName, KCDTIdWCDMAConfigDaemonName, NULL },

    { EPacketDataEnableLcpExtension, KCDTIdWCDMAEnableLCPExtensions, NULL },

    { EPacketDataDisablePlainTextAuth, KCDTIdWCDMADisablePlainTextAuth, NULL,

      R_QTN_SET_PASSWD_AUT,

      0, 0, 0, NULL, NULL },

    { EPacketDataApType, KCDTIdAPType, NULL },

    { EPacketDataQoSWarningTimeOut, KCDTIdQOSWarningTimeOut, NULL },

    { EPacketDataServiceEnableLLMNR, KCDTIdServiceEnableLlmnr, NULL },

    { 0, 0, NULL }

};

static const TCmAttribConvTable SQoSDataConvTbl[] =

    {

    // iAttribId, iCommsDatId, iValidFuncL, 

    // iTitleId, 

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

    { EGPRSReqTrafficClass, EPacketDataRangeMax, NULL },

    { EGPRSReqTrafficClass, KCDTIdWCDMAReqTrafficClass, NULL },

    { EGPRSMinTrafficClass, KCDTIdWCDMAMinTrafficClass, NULL },

    { EGPRSReqDeliveryOrder, KCDTIdWCDMAReqDeliveryOrder, NULL },

    { GPRSMinDeliveryOrder, KCDTIdWCDMAMinDeliveryOrder, NULL },

    { EGPRSReqDeliverErroneousSDU, KCDTIdWCDMAReqDeliverErroneousSDU, NULL },

    { EGPRSMinDeliverErroneousSDU, KCDTIdWCDMAMinDeliverErroneousSDU, NULL },

    { EGPRSReqMaxSDUSize, KCDTIdWCDMAReqMaxSDUSize, NULL },

    { EGPRSMinAcceptableMaxSDUSize, KCDTIdWCDMAMinAcceptableMaxSDUSize, NULL },

    { EGPRSReqMaxUplinkRate, KCDTIdWCDMAReqMaxUplinkRate, NULL },

    { EGPRSReqMinUplinkRate, KCDTIdWCDMAReqMinUplinkRate, NULL },

    { EGPRSReqMaxDownlinkRate, KCDTIdWCDMAReqMaxDownlinkRate, NULL },

    { EGPRSReqMinDownlinkRate, KCDTIdWCDMAReqMinDownlinkRate, NULL },

    { EGPRSReqBER, KCDTIdWCDMAReqBER, NULL },

    { EGPRSMaxBER, KCDTIdWCDMAMaxBER, NULL },

    { EGPRSReqSDUErrorRatio, KCDTIdWCDMAReqSDUErrorRatio, NULL },

    { EGPRSMaxSDUErrorRatio, KCDTIdWCDMAMaxSDUErrorRatio, NULL },

    { EGPRSReqTrafficHandlingPriority, KCDTIdWCDMAReqTrafficHandlingPriority, NULL },

    { EGPRSMinTrafficHandlingPriority, KCDTIdWCDMAMinTrafficHandlingPriority, NULL },

    { EGPRSReqTransferDelay, KCDTIdWCDMAReqTransferDelay, NULL },

    { EGPRSMaxTransferDelay, KCDTIdWCDMAMaxTransferDelay, NULL },

    { EGPRSReqGuaranteedUplinkRate, KCDTIdWCDMAReqGuaranteedUplinkRate, NULL },

    { EGPRSMinGuaranteedUplinkRate, KCDTIdWCDMAMinGuaranteedUplinkRate, NULL },

    { EGPRSReqGuaranteedDownlinkRate, KCDTIdWCDMAReqGuaranteedDownlinkRate, NULL },

    { EGPRSMinGuaranteedDownlinkRate, KCDTIdWCDMAMinGuaranteedDownlinkRate, NULL },

    { EGPRSSignallingIndication, KCDTIdWCDMASignallingIndication, NULL },

    { EGPRS_ImCnSignallingIndication, KCDTIdWCDMAImCmSignallingIndication, NULL },

    { EGPRSSourceStatisticsDescriptor, KCDTIdWCDMASourceStatisticsDescriptor, NULL },

    { 0, 0, NULL }

    };

static const TCmCommonAttrConvArrayItem SCommonConvTbl[] =

{

    { EPacketDataIFParams, ECmIFParams },

    { EPacketDataIFNetworks, ECmIFNetworks },

    { EPacketDataIFPromptForAuth, ECmIFPromptForAuth },

    { EPacketDataIFAuthName, ECmIFAuthName },

    { EPacketDataIFAuthPass, ECmIFAuthPass },

    { EPacketDataIFAuthRetries, ECmIFAuthRetries },

    { EPacketDataIPNetmask, ECmIPNetmask },

    { EPacketDataIPGateway, ECmIPGateway },

    { EPacketDataIPAddrFromServer, ECmIPAddFromServer },

    { EPacketDataIPAddr, ECmIPAddress },

    { EPacketDataIPDNSAddrFromServer, ECmIPDNSAddrFromServer },

    { EPacketDataIPNameServer1, ECmIPNameServer1 },

    { EPacketDataIPNameServer2, ECmIPNameServer2 },

    { EPacketDataIPIP6DNSAddrFromServer, ECmIP6DNSAddrFromServer },

    { EPacketDataIPIP6NameServer1, ECmIP6NameServer1 },

    { EPacketDataIPIP6NameServer2, ECmIP6NameServer2 },

    { EPacketDataIPAddrLeaseValidFrom, ECmIPAddrLeaseValidFrom },

    { EPacketDataIPAddrLeaseValidTo, ECmIPAddrLeaseValidTo },

    { EPacketDataConfigDaemonManagerName, ECmConfigDaemonManagerName },

    { EPacketDataConfigDaemonName, ECmConfigDaemonName },

    { EPacketDataEnableLcpExtension, ECmEnableLPCExtension },

    { EPacketDataDisablePlainTextAuth, ECmDisablePlainTextAuth },

    { 0, 0 }

    };

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

static TBool SetPDPTypeL( CCmPluginBaseEng* aThis, 

                          TUint32 aAttribute, 

                          const TAny* aValue )

    {

    (void)aAttribute;

    CCmPluginPacketData* myThis = static_cast<CCmPluginPacketData*>( aThis );

    myThis->SetPDPTypeL( (RPacketContext::TProtocolType)(TInt)aValue );

    return ETrue;

    }

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

class CCmPDCoverageCheck : public CActive

    {

    enum EPacketCoverageState

        {

        EServiceStatus,

        EPDPAttach,

        EPDPDetach,                        

        };

    public:

        CCmPDCoverageCheck();

        ~CCmPDCoverageCheck();

        TBool IsThereCoverageL();

    protected:  // from CActive

        virtual void DoCancel();

        virtual void RunL();

    private:

        TUint32                 iProgState;

        TBool                   iCoverage;

        CActiveSchedulerWait    iWait;    

        RTelServer              iServer;

        RPhone                  iPhone;

        RPacketService          iService;        

    };

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

// CCmPDCoverageCheck::CCmPDCoverageCheck()

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

//

CCmPDCoverageCheck::CCmPDCoverageCheck() : CActive( EPriorityStandard )

    {

    CActiveScheduler::Add( this );

    }

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

// CCmPDCoverageCheck::~CCmPDCoverageCheck()

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

//

CCmPDCoverageCheck::~CCmPDCoverageCheck()

    {

    Cancel();

    iService.Close();

    iPhone.Close();

    iServer.Close();

    }

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

// CCmPDCoverageCheck::DoCancel

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

//

void CCmPDCoverageCheck::DoCancel()

    {

    iWait.AsyncStop();

    }

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

// CCmPDCoverageCheck::RunL

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

//

void CCmPDCoverageCheck::RunL()

    {

    switch( iProgState )

        {

        case EPDPAttach:

            {

            if( !iStatus.Int() )

                // PDP context created -> there's a usable PD coverage.

                {

                iService.Detach( iStatus );

                SetActive();

                iCoverage = ETrue;

                iProgState = EPDPDetach;

                }

            else

                // something went wrong -> no coverage.

                {

                iWait.AsyncStop();

                }

            }

            break;

        case EPDPDetach:

            {

            iWait.AsyncStop();

            }

            break;

        default:

            {

            User::Leave( KErrCorrupt );

            }

        }

    }

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

// CCmPDCoverageCheck::IsThereCoverageL

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

//

TBool CCmPDCoverageCheck::IsThereCoverageL()

    {

    iProgState = EServiceStatus;

    iCoverage = EFalse;

    User::LeaveIfError( iServer.Connect() );

    CLOG_WRITE( "Server open" );

    RTelServer::TPhoneInfo info;

    User::LeaveIfError( iServer.GetPhoneInfo( 0, info ) );

    CLOG_WRITE( "Phone info ok" );

    User::LeaveIfError( iPhone.Open(iServer, info.iName ) );

    CLOG_WRITE( "Phone open" );

    User::LeaveIfError( iService.Open( iPhone ) );

    CLOG_WRITE( "service ok" );

    RPacketService::TStatus status;

    User::LeaveIfError( iService.GetStatus( status ) );

    if( status == RPacketService::EStatusAttached ||

        status == RPacketService::EStatusActive || 

        status == RPacketService::EStatusSuspended )

        // Attached/active/suspened, so there's a coverage

        {

        iCoverage = ETrue;

        }

    else if( status == RPacketService::EStatusUnattached )

        {

        iProgState = EPDPAttach;

        iService.Attach( iStatus );

        SetActive();

        iWait.Start();

        }

    else

        {

        CLOG_WRITE( "Unknown state" );

        }

    User::LeaveIfError( iStatus.Int() );

    return iCoverage;

    }

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

// CCmPluginPacketData::NewOutgoingL

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

//

CCmPluginPacketData* CCmPluginPacketData::NewL(

                                            TCmPluginInitParam* aInitParam )

	{

	CCmPluginPacketData* self = new ( ELeave ) CCmPluginPacketData( 

	                                                    aInitParam, ETrue );

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );

	return self;

	}

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

// CCmPluginPacketData::~CCmPluginPacketData

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

//

CCmPluginPacketData::~CCmPluginPacketData()

	{

	CCmPluginPacketData::AdditionalReset();	

	RemoveResourceFile( KPluginPacketDataResDirAndFileName );	

	CLOG_CLOSE;

	}

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

// CCmPluginPacketData::CreateInstanceL

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

//

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

    {

    CCmPluginPacketData* self = new( ELeave ) CCmPluginPacketData( &aInitParam, ETrue );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CCmPluginPacketData::CCmPluginPacketData

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

//

CCmPluginPacketData::CCmPluginPacketData( TCmPluginInitParam* aInitParam,

                                          TBool aOutgoing )

    : CCmPluginBaseEng( aInitParam )

    , iOutgoing( aOutgoing )

	{

	CLOG_CREATE;

	iBearerType = KUidPacketDataBearerType;

	}

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

// CCmPluginPacketData::ConstructL

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

//

void CCmPluginPacketData::ConstructL()

	{

	CCmPluginBaseEng::ConstructL();

    AddResourceFileL( KPluginPacketDataResDirAndFileName );

	AddConverstionTableL( (CCDRecordBase**)&iServiceRecord, NULL, SPacketDataConvTbl );

    AddConverstionTableL( (CCDRecordBase**)&iPacketDataQoSRecord, NULL, SQoSDataConvTbl );

	AddCommonConversionTableL( SCommonConvTbl );

	}

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

// CCmPluginPacketData::GetIntAttributeL()

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

//

TUint32 CCmPluginPacketData::GetIntAttributeL( const TUint32 aAttribute ) const

	{

    LOGGER_ENTERFN( "CCmPluginPacketData::GetIntAttributeL" );

    TUint32 retVal( 0 );

    switch( aAttribute )

        {

        case ECmBearerIcon:

            {

            TAknsItemID id;

            MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance();

            TParse mbmFile;

            User::LeaveIfError( mbmFile.Set( KPacketDataFileIcons, 

                                                    &KDC_BITMAP_DIR, NULL ) );

            retVal = (TUint32)AknsUtils::CreateGulIconL( 

                                    skinInstance, 

                                    id,

                                    mbmFile.FullName(), 

                                    EMbmCmpluginpacketdataQgn_prop_wml_gprs, 

                                    EMbmCmpluginpacketdataQgn_prop_wml_gprs_mask );

            }

            break;

        case ECmBearerAvailableIcon:

            {

            TAknsItemID id;

            MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance();

            TParse mbmFile;

            User::LeaveIfError( mbmFile.Set( KPacketDataFileIcons, &KDC_BITMAP_DIR, NULL ) );

            retVal = (TUint32)AknsUtils::CreateGulIconL( 

                    skinInstance, 

                    id,

                    mbmFile.FullName(), 

                    EMbmCmpluginpacketdataQgn_prop_set_conn_bearer_avail_packetdata, 

                    EMbmCmpluginpacketdataQgn_prop_set_conn_bearer_avail_packetdata_mask );

            }

            break;

        case ECmCommsDBBearerType:

            {

            retVal = KCommDbBearerWcdma;

            }

            break;

        case ECmDefaultUiPriority:

        case ECmDefaultPriority:

            {

            TPtrC buf;

            if( iOutgoing )

                {

                buf.Set( KCDTypeNameOutgoingWCDMA );

                }

            else

                {

                buf.Set( KCDTypeNameIncomingWCDMA );

                }

            retVal = aAttribute == ECmDefaultPriority ?

                     GlobalBearerPriority( buf ) :

                     GlobalUiBearerPriority( buf );

            if( retVal == KDataMobilitySelectionPolicyPriorityWildCard )

                {

                retVal = KDefaultPriorityPacketData;

                }

            }

            break;

        default:

            {

            retVal = CCmPluginBaseEng::GetIntAttributeL( aAttribute );

            }

            break;

        }

    return retVal;

	}

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

// CCmPluginPacketData::GetBoolAttributeL()