1 /*

     2 * Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Dialog for editing settings for a packet data connection 

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 

    21 // System

    22 #include <AknsUtils.h>

    23 #include <data_caging_path_literals.hrh>

    24 #include <cmpluginpacketdata.mbg>           // icons

    25 #include <cmpacketdataui.rsg>

    26 #include <AknQueryDialog.h>

    27 #include <StringLoader.h>

    28 #include <cmmanager.rsg>

    29 #include <featmgr.h>                     // FeatureManager

    30 #include <centralrepository.h>           // CRepository 

    31 #include <CoreApplicationUIsSDKCRKeys.h> // KCRUidCoreApplicationUIs, 

    32 

    33 // User

    34 #include "cmpluginpacketdata.h"

    35 #include <cmpluginpacketdatadef.h>

    36 #include "cmpacketdatacommonconstants.h"

    37 #include "cmlogger.h"

    38 #include "cmppacketdatasettingsdlg.h"

    39 #include <cmpsettingsconsts.h>

    40 #include "datamobilitycommsdattypes.h"

    41 #include <cmcommonconstants.h>

    42 #include <cmmanagerdef.h>

    43 

    44 using namespace CMManager;

    45 using namespace CommsDat;

    46 

    47 // ================= CONSTANTS =======================

    48 

    49 const TUint32 KDefaultPriorityPacketData = 1;

    50 

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

    52 _LIT( KModemBearerPacketData, "GPRS Modem" );

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

    54 _LIT( KDefaultQosDataRecordName, "PRIMARY1" );

    55 _LIT( KDefaultQosDataRecordNamewithSpace, "PRIMARY1 " );

    56 

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

    58 

    59 /**

    60 * Function to check and set PDP type and IfNetwork.

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

    62 * @param aAttribute attribute client wants to set

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

    64 */

    65 static TBool SetPDPTypeL( CCmPluginBaseEng* aThis, 

    66                    TUint32 aAttribute, 

    67                    const TAny* aValue );

    68 

    69 static const TCmAttribConvTable SPacketDataConvTbl[] = 

    70     {

    71     // iAttribId, iCommsDatId, iValidFuncL, 

    72     // iTitleId, 

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

    74     { EPacketDataAPName, EGPRSReqTrafficClass-1, NULL,

    75       0,

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

    77     { EPacketDataAPName, KCDTIdAPN, NULL,

    78       R_GPRS_PLUGIN_VIEW_AP_NAME,

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

    80     { EPacketDataPDPType, KCDTIdWCDMPDPType, &SetPDPTypeL,

    81       R_GPRS_PLUGIN_VIEW_PDP_TYPE,

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

    83     { EPacketDataPDPAddress, KCDTIdWCDMAPDPAddress, NULL },

    84     { EPacketDataReqPrecedence, KCDTIdReqPrecedence, NULL },

    85     { EPacketDataReqDelay, KCDTIdReqDelay, NULL },

    86     { EPacketDataReliability, KCDTIdReqReliability, NULL },

    87     { EPacketDataPeakThroughput, KCDTIdReqPeakThroughput, NULL },

    88     { EPacketDataMeanThroughput, KCDTIdReqMeanThroughput, NULL },

    89     { EPacketDataMinPrecedence, KCDTIdMinPrecedence, NULL },

    90     { EPacketDataMinDelay, KCDTIdMinDelay, NULL },

    91     { EPacketDataMinReliability, KCDTIdMinReliability, NULL },

    92     { EPacketDataMinPeakThroughput, KCDTIdMinPeakThroughput, NULL },

    93     { EPacketDataMinMeanThroughput, KCDTIdMinMeanThroughput, NULL },

    94     { EPacketDataDataCompression, KCDTIdWCDMADataCompression, NULL },

    95     { EPacketDataHeaderCompression, KCDTIdWCDMAHeaderCompression, NULL },

    96     { EPacketDataUseEdge, KCDTIdWCDMAUseEdge, NULL },

    97     { EPacketDataAnonymousAccess, KCDTIdWCDMAAnonymousAccess, NULL },

    98     { EPacketDataIFParams, KCDTIdWCDMAIfParams, NULL },

    99     { EPacketDataIFNetworks, KCDTIdWCDMAIfNetworks, NULL },

   100     { EPacketDataIFPromptForAuth, KCDTIdWCDMAIfPromptForAuth, NULL,

   101       R_QTN_SET_PROMPT_PASSWD,

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

   103     { EPacketDataIFAuthName, KCDTIdWCDMAIfAuthName, NULL,

   104       R_QTN_SET_AP_USERNAME,

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

   106     { EPacketDataIFAuthPass, KCDTIdWCDMAIfAuthPass, NULL,

   107       R_QTN_SET_AP_PASSWD,

   108       KCmMaxPasswordLength, EConvPassword, R_AVKON_NUMERIC_PASSWORD_BLANKING_TEXT, NULL, NULL },

   109     { EPacketDataIFAuthRetries, KCDTIdWCDMAIfAuthRetries, NULL },

   110     { EPacketDataIPNetmask, KCDTIdWCDMAIPNetMask, &CheckIPv4ValidityL },

   111     { EPacketDataIPGateway, KCDTIdWCDMAIPGateway, &CheckIPv4ValidityL },

   112     { EPacketDataIPAddrFromServer, KCDTIdWCDMAIPAddrFromServer, NULL },

   113     { EPacketDataIPAddr, KCDTIdWCDMAIPAddr, &CheckIPv4ValidityL,

   114       R_QTN_SET_IP_ADDRESS,

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

   116     { EPacketDataIPDNSAddrFromServer, KCDTIdWCDMAIPDNSAddrFromServer, NULL,

   117       R_QTN_SET_DNS_SERVERS_IP,

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

   119     { EPacketDataIPNameServer1, KCDTIdWCDMAIPNameServer1, &CheckIPv4ValidityL,

   120       R_QTN_SET_PRIMARY_DNS,

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

   122     { EPacketDataIPNameServer2, KCDTIdWCDMAIPNameServer2, &CheckIPv4ValidityL,

   123       R_QTN_SET_SECONDARY_DNS,

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

   125     { EPacketDataIPIP6DNSAddrFromServer, KCDTIdWCDMAIP6DNSAddrFromServer, NULL,

   126       R_QTN_SET_DNS_SERVERS_IP,

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

   128     { EPacketDataIPIP6NameServer1, KCDTIdWCDMAIP6NameServer1, &CheckIPv6ValidityL },

   129     { EPacketDataIPIP6NameServer2, KCDTIdWCDMAIP6NameServer2, &CheckIPv6ValidityL },

   130     { EPacketDataIPAddrLeaseValidFrom, KCDTIdWCDMAIPAddrLeaseValidFrom, NULL },

   131     { EPacketDataIPAddrLeaseValidTo, KCDTIdWCDMAIPAddrLeaseValidTo, NULL },

   132     { EPacketDataConfigDaemonManagerName, KCDTIdWCDMAConfigDaemonManagerName, NULL },

   133     { EPacketDataConfigDaemonName, KCDTIdWCDMAConfigDaemonName, NULL },

   134     { EPacketDataEnableLcpExtension, KCDTIdWCDMAEnableLCPExtensions, NULL },

   135     { EPacketDataDisablePlainTextAuth, KCDTIdWCDMADisablePlainTextAuth, NULL,

   136       R_QTN_SET_PASSWD_AUT,

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

   138     { EPacketDataApType, KCDTIdAPType, NULL },

   139     { EPacketDataQoSWarningTimeOut, KCDTIdQOSWarningTimeOut, NULL },

   140     { EPacketDataServiceEnableLLMNR, KCDTIdServiceEnableLlmnr, NULL },

   141     { 0, 0, NULL }

   142 };

   143 

   144 static const TCmAttribConvTable SQoSDataConvTbl[] =

   145     {

   146     // iAttribId, iCommsDatId, iValidFuncL, 

   147     // iTitleId, 

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

   149     { EGPRSReqTrafficClass, EPacketDataRangeMax, NULL },

   150     { EGPRSReqTrafficClass, KCDTIdWCDMAReqTrafficClass, NULL },

   151     { EGPRSMinTrafficClass, KCDTIdWCDMAMinTrafficClass, NULL },

   152     { EGPRSReqDeliveryOrder, KCDTIdWCDMAReqDeliveryOrder, NULL },

   153     { GPRSMinDeliveryOrder, KCDTIdWCDMAMinDeliveryOrder, NULL },

   154     { EGPRSReqDeliverErroneousSDU, KCDTIdWCDMAReqDeliverErroneousSDU, NULL },

   155     { EGPRSMinDeliverErroneousSDU, KCDTIdWCDMAMinDeliverErroneousSDU, NULL },

   156     { EGPRSReqMaxSDUSize, KCDTIdWCDMAReqMaxSDUSize, NULL },

   157     { EGPRSMinAcceptableMaxSDUSize, KCDTIdWCDMAMinAcceptableMaxSDUSize, NULL },

   158     { EGPRSReqMaxUplinkRate, KCDTIdWCDMAReqMaxUplinkRate, NULL },

   159     { EGPRSReqMinUplinkRate, KCDTIdWCDMAReqMinUplinkRate, NULL },

   160     { EGPRSReqMaxDownlinkRate, KCDTIdWCDMAReqMaxDownlinkRate, NULL },

   161     { EGPRSReqMinDownlinkRate, KCDTIdWCDMAReqMinDownlinkRate, NULL },

   162     { EGPRSReqBER, KCDTIdWCDMAReqBER, NULL },

   163     { EGPRSMaxBER, KCDTIdWCDMAMaxBER, NULL },

   164     { EGPRSReqSDUErrorRatio, KCDTIdWCDMAReqSDUErrorRatio, NULL },

   165     { EGPRSMaxSDUErrorRatio, KCDTIdWCDMAMaxSDUErrorRatio, NULL },

   166     { EGPRSReqTrafficHandlingPriority, KCDTIdWCDMAReqTrafficHandlingPriority, NULL },

   167     { EGPRSMinTrafficHandlingPriority, KCDTIdWCDMAMinTrafficHandlingPriority, NULL },

   168     { EGPRSReqTransferDelay, KCDTIdWCDMAReqTransferDelay, NULL },

   169     { EGPRSMaxTransferDelay, KCDTIdWCDMAMaxTransferDelay, NULL },

   170     { EGPRSReqGuaranteedUplinkRate, KCDTIdWCDMAReqGuaranteedUplinkRate, NULL },

   171     { EGPRSMinGuaranteedUplinkRate, KCDTIdWCDMAMinGuaranteedUplinkRate, NULL },

   172     { EGPRSReqGuaranteedDownlinkRate, KCDTIdWCDMAReqGuaranteedDownlinkRate, NULL },

   173     { EGPRSMinGuaranteedDownlinkRate, KCDTIdWCDMAMinGuaranteedDownlinkRate, NULL },

   174     { EGPRSSignallingIndication, KCDTIdWCDMASignallingIndication, NULL },

   175     { EGPRS_ImCnSignallingIndication, KCDTIdWCDMAImCmSignallingIndication, NULL },

   176     { EGPRSSourceStatisticsDescriptor, KCDTIdWCDMASourceStatisticsDescriptor, NULL },

   177     { 0, 0, NULL }

   178     };

   179 

   180 static const TCmCommonAttrConvArrayItem SCommonConvTbl[] =

   181 {

   182     { EPacketDataIFParams, ECmIFParams },

   183     { EPacketDataIFNetworks, ECmIFNetworks },

   184     { EPacketDataIFPromptForAuth, ECmIFPromptForAuth },

   185     { EPacketDataIFAuthName, ECmIFAuthName },

   186     { EPacketDataIFAuthPass, ECmIFAuthPass },

   187     { EPacketDataIFAuthRetries, ECmIFAuthRetries },

   188     { EPacketDataIPNetmask, ECmIPNetmask },

   189     { EPacketDataIPGateway, ECmIPGateway },

   190     { EPacketDataIPAddrFromServer, ECmIPAddFromServer },

   191     { EPacketDataIPAddr, ECmIPAddress },

   192     { EPacketDataIPDNSAddrFromServer, ECmIPDNSAddrFromServer },

   193     { EPacketDataIPNameServer1, ECmIPNameServer1 },

   194     { EPacketDataIPNameServer2, ECmIPNameServer2 },

   195     { EPacketDataIPIP6DNSAddrFromServer, ECmIP6DNSAddrFromServer },

   196     { EPacketDataIPIP6NameServer1, ECmIP6NameServer1 },

   197     { EPacketDataIPIP6NameServer2, ECmIP6NameServer2 },

   198     { EPacketDataIPAddrLeaseValidFrom, ECmIPAddrLeaseValidFrom },

   199     { EPacketDataIPAddrLeaseValidTo, ECmIPAddrLeaseValidTo },

   200     { EPacketDataConfigDaemonManagerName, ECmConfigDaemonManagerName },

   201     { EPacketDataConfigDaemonName, ECmConfigDaemonName },

   202     { EPacketDataEnableLcpExtension, ECmEnableLPCExtension },

   203     { EPacketDataDisablePlainTextAuth, ECmDisablePlainTextAuth },

   204     { 0, 0 }

   205     };

   206     

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

   208     

   209 static TBool SetPDPTypeL( CCmPluginBaseEng* aThis, 

   210                           TUint32 aAttribute, 

   211                           const TAny* aValue )

   212     {

   213     (void)aAttribute;

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

   215     

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

   217     

   218     return ETrue;

   219     }

   220 

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

   222 

   223 class CCmPDCoverageCheck : public CActive

   224     {        

   225     public:

   226     

   227         CCmPDCoverageCheck();

   228         ~CCmPDCoverageCheck();

   229         

   230         TBool IsThereCoverageL();

   231         

   232     protected:  // from CActive

   233     

   234         virtual void DoCancel();

   235         virtual void RunL();

   236         

   237     private:

   238 

   239         TBool IsPhoneOfflineL() const;     	        

   240 

   241     private:

   242 

   243         TBool                   iCoverage;

   244         CActiveSchedulerWait    iWait;    

   245         RTelServer              iServer;

   246         RPhone                  iPhone;

   247         RPacketService          iService;

   248         RPacketService::TRegistrationStatus iNwRegStatus;        

   249     };

   250 

   251 // ----------------------------------------------------------------------------

   252 // CCmPDCoverageCheck::CCmPDCoverageCheck()

   253 // ----------------------------------------------------------------------------

   254 //

   255 CCmPDCoverageCheck::CCmPDCoverageCheck() : CActive( EPriorityStandard )

   256     {

   257     CActiveScheduler::Add( this );

   258     }

   259     

   260 // ----------------------------------------------------------------------------

   261 // CCmPDCoverageCheck::~CCmPDCoverageCheck()

   262 // ----------------------------------------------------------------------------

   263 //

   264 CCmPDCoverageCheck::~CCmPDCoverageCheck()

   265     {

   266     Cancel();

   267 

   268     iService.Close();

   269     iPhone.Close();

   270     iServer.Close();

   271     }

   272     

   273 // ----------------------------------------------------------------------------

   274 // CCmPDCoverageCheck::DoCancel

   275 // ----------------------------------------------------------------------------

   276 //

   277 void CCmPDCoverageCheck::DoCancel()

   278     {

   279     iWait.AsyncStop();

   280     }

   281     

   282 // ----------------------------------------------------------------------------

   283 // CCmPDCoverageCheck::RunL

   284 // ----------------------------------------------------------------------------

   285 //

   286 void CCmPDCoverageCheck::RunL()

   287     {

   288     if( !iStatus.Int() )

   289         {

   290         CLOG_WRITE_1( "CCmPDCoverageCheck::RunL: iNwRegStatus: [%d]", iNwRegStatus );

   291         	

   292         if ( iNwRegStatus == RPacketService::ERegisteredOnHomeNetwork ||

   293              iNwRegStatus == RPacketService::ERegisteredRoaming ||

   294              iNwRegStatus == RPacketService::ENotRegisteredButAvailable )

   295             {

   296             iCoverage = ETrue;	

   297             }	

   298         iWait.AsyncStop();

   299         }

   300     else

   301         // something went wrong -> no coverage.

   302         {

   303         CLOG_WRITE_1( "CCmPDCoverageCheck::RunL: FAILED: [%d]", iStatus.Int() );        	

   304         iWait.AsyncStop();

   305         }

   306     }

   307     

   308 // ----------------------------------------------------------------------------

   309 // CCmPDCoverageCheck::IsThereCoverageL

   310 // ----------------------------------------------------------------------------

   311 //

   312 TBool CCmPDCoverageCheck::IsThereCoverageL()

   313     {

   314     iCoverage = EFalse;

   315     

   316     if ( !IsPhoneOfflineL() )

   317         {

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

   319         CLOG_WRITE( "Server open" );

   320     

   321         RTelServer::TPhoneInfo info;

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

   323         CLOG_WRITE( "Phone info ok" );

   324     

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

   326         CLOG_WRITE( "Phone open" );

   327 

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

   329         CLOG_WRITE( "service ok" );

   330 

   331         iService.GetNtwkRegStatus( iStatus, iNwRegStatus );

   332         SetActive();

   333         iWait.Start();

   334     

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

   336         }

   337     

   338     return iCoverage;

   339     }

   340 

   341 // ----------------------------------------------------------------------------

   342 // CCmPDCoverageCheck::IsPhoneOfflineL

   343 // ----------------------------------------------------------------------------

   344 //

   345 TBool CCmPDCoverageCheck::IsPhoneOfflineL() const

   346     {

   347     if ( FeatureManager::FeatureSupported( KFeatureIdOfflineMode ) )

   348         {

   349         CRepository* repository = CRepository::NewLC( KCRUidCoreApplicationUIs );

   350         TInt connAllowed( ECoreAppUIsNetworkConnectionAllowed );

   351         

   352         repository->Get( KCoreAppUIsNetworkConnectionAllowed, connAllowed );

   353         CleanupStack::PopAndDestroy( repository );

   354         	 

   355         if ( !connAllowed )

   356             {

   357             CLOG_WRITE( "Phone is in offline mode." );

   358             return ETrue;

   359             }

   360         }

   361         

   362     CLOG_WRITE( "Phone is NOT in offline mode." );

   363     return EFalse;

   364     }

   365     

   366 // ----------------------------------------------------------------------------

   367 // CCmPluginPacketData::NewOutgoingL

   368 // ----------------------------------------------------------------------------

   369 //

   370 CCmPluginPacketData* CCmPluginPacketData::NewL(

   371                                             TCmPluginInitParam* aInitParam )

   372 	{

   373 	CCmPluginPacketData* self = new ( ELeave ) CCmPluginPacketData( 

   374 	                                                    aInitParam, ETrue );

   375 	CleanupStack::PushL( self );

   376 	self->ConstructL();

   377 	CleanupStack::Pop( self );

   378 	return self;

   379 	}

   380 

   381 // ----------------------------------------------------------------------------

   382 // CCmPluginPacketData::~CCmPluginPacketData

   383 // ----------------------------------------------------------------------------

   384 //

   385 CCmPluginPacketData::~CCmPluginPacketData()

   386 	{

   387 	CCmPluginPacketData::AdditionalReset();	

   388 	RemoveResourceFile( KPluginPacketDataResDirAndFileName );	

   389 	CLOG_CLOSE;

   390 	}

   391 

   392 // ----------------------------------------------------------------------------

   393 // CCmPluginPacketData::CreateInstanceL

   394 // ----------------------------------------------------------------------------

   395 //

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

   397     {

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

   399     CleanupStack::PushL( self );

   400     self->ConstructL();

   401     CleanupStack::Pop( self );

   402 

   403     return self;

   404     }

   405     

   406 // ----------------------------------------------------------------------------

   407 // CCmPluginPacketData::CCmPluginPacketData

   408 // ----------------------------------------------------------------------------

   409 //

   410 CCmPluginPacketData::CCmPluginPacketData( TCmPluginInitParam* aInitParam,

   411                                           TBool aOutgoing )

   412     : CCmPluginBaseEng( aInitParam )

   413     , iOutgoing( aOutgoing )

   414 	{

   415 	CLOG_CREATE;

   416 	

   417 	iBearerType = KUidPacketDataBearerType;

   418 	}

   419 

   420 // ----------------------------------------------------------------------------

   421 // CCmPluginPacketData::ConstructL

   422 // ----------------------------------------------------------------------------

   423 //

   424 void CCmPluginPacketData::ConstructL()

   425 	{

   426 	CCmPluginBaseEng::ConstructL();

   427 

   428     AddResourceFileL( KPluginPacketDataResDirAndFileName );

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

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

   431 	AddCommonConversionTableL( SCommonConvTbl );

   432 	}

   433 	

   434 // ----------------------------------------------------------------------------

   435 // CCmPluginPacketData::GetIntAttributeL()

   436 // ----------------------------------------------------------------------------

   437 //

   438 TUint32 CCmPluginPacketData::GetIntAttributeL( const TUint32 aAttribute ) const

   439 	{

   440     LOGGER_ENTERFN( "CCmPluginPacketData::GetIntAttributeL" );

   441 

   442     TUint32 retVal( 0 );

   443     

   444     switch( aAttribute )

   445         {

   446         case ECmBearerIcon:

   447             {

   448             TAknsItemID id;

   449             MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance();

   450                    

   451             TParse mbmFile;

   452             User::LeaveIfError( mbmFile.Set( KPacketDataFileIcons, 

   453                                                     &KDC_BITMAP_DIR, NULL ) );

   454 

   455                    

   456             retVal = (TUint32)AknsUtils::CreateGulIconL( 

   457                                     skinInstance, 

   458                                     id,

   459                                     mbmFile.FullName(), 

   460                                     EMbmCmpluginpacketdataQgn_prop_wml_gprs, 

   461                                     EMbmCmpluginpacketdataQgn_prop_wml_gprs_mask );

   462             }

   463             break;

   464                

   465         case ECmBearerAvailableIcon:

   466             {

   467             TAknsItemID id;

   468             MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance();

   469                    

   470             TParse mbmFile;

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

   472                    

   473             retVal = (TUint32)AknsUtils::CreateGulIconL( 

   474                     skinInstance, 

   475                     id,

   476                     mbmFile.FullName(), 

   477                     EMbmCmpluginpacketdataQgn_prop_set_conn_bearer_avail_packetdata, 

   478                     EMbmCmpluginpacketdataQgn_prop_set_conn_bearer_avail_packetdata_mask );

   479             }

   480             break;

   481             

   482         case ECmCommsDBBearerType:

   483             {

   484             retVal = KCommDbBearerWcdma;

   485             }

   486             break;

   487             

   488         case ECmDefaultUiPriority:

   489         case ECmDefaultPriority:

   490             {

   491             TPtrC buf;

   492             

   493             if( iOutgoing )

   494                 {

   495                 buf.Set( KCDTypeNameOutgoingWCDMA );

   496                 }

   497             else

   498                 {

   499                 buf.Set( KCDTypeNameIncomingWCDMA );

   500                 }

   501 

   502             retVal = aAttribute == ECmDefaultPriority ?

   503                      GlobalBearerPriority( buf ) :

   504                      GlobalUiBearerPriority( buf );

   505             

   506             if( retVal == KDataMobilitySelectionPolicyPriorityWildCard )

   507                 {

   508                 retVal = KDefaultPriorityPacketData;

   509                 }

   510             }

   511             break;

   512             

   513         default:

   514             {

   515             retVal = CCmPluginBaseEng::GetIntAttributeL( aAttribute );

   516             }

   517             break;

   518         }

   519         

   520     return retVal;

   521 	}

   522 

   523 // ----------------------------------------------------------------------------

   524 // CCmPluginPacketData::GetBoolAttributeL()

   525 // ----------------------------------------------------------------------------

   526 //

   527 TBool CCmPluginPacketData::GetBoolAttributeL( const TUint32 aAttribute ) const

   528 	{

   529     LOGGER_ENTERFN( "CCmPluginPacketData::GetBoolAttributeL" );

   530 

   531     TBool retVal( EFalse );

   532 

   533     switch( aAttribute )

   534         {

   535         case EPacketDataOutGoing:

   536             {

   537             retVal = iOutgoing;

   538             }

   539             break;

   540             

   541         case ECmCoverage:

   542             // In default the plugin has no network coverage

   543             {

   544             retVal = CheckNetworkCoverageL();

   545             }

   546             break;

   547             

   548         case ECmAddToAvailableList:

   549             {

   550             retVal = ETrue;

   551             }

   552             break;

   553             

   554         case ECmBearerHasUi:

   555             {

   556             retVal = ETrue;

   557             }

   558             break;

   559             

   560         default:

   561             {

   562             retVal = CCmPluginBaseEng::GetBoolAttributeL( aAttribute );

   563             }

   564         }

   565         

   566     return retVal;

   567 	}

   568 

   569 // ----------------------------------------------------------------------------

   570 // CCmPluginPacketData::GetStringAttributeL()

   571 // ----------------------------------------------------------------------------

   572 //

   573 HBufC* CCmPluginPacketData::GetStringAttributeL( const TUint32 aAttribute ) const

   574 	{

   575     LOGGER_ENTERFN( "CCmPluginPacketData::GetStringAttributeL" );

   576 

   577 	HBufC* retVal = NULL;

   578 	

   579 	switch( aAttribute )

   580 	    {

   581 	    case ECmBearerAvailableName:

   582 	        {

   583 	        retVal = AllocReadL( R_QTN_NETW_CONSET_BEARER_AVAILABLE_PACKET_DATA );

   584 	        }

   585 	        break;

   586 	        

   587 	    case ECmBearerSupportedName:

   588 	        {

   589 	        retVal = AllocReadL( R_QTN_NETW_CONSET_BEARER_SUPPORTED_PACKET_DATA );

   590 	        }

   591 	        break;

   592 	        

   593         case ECmBearerAvailableText:

   594             {

   595             retVal = AllocReadL( R_QTN_NETW_CONSET_PACKET_DATA_AVAILABLE );

   596             }

   597             break;

   598             

   599 	    case ECmBearerNamePopupNote:

   600 	        {

   601 	        retVal = AllocReadL( R_QTN_NETW_CONSET_POPUP_BEARER_PACKET_DATA );

   602 	        }

   603 	        break;

   604 

   605 	    case ECmBearerSettingName:

   606 	        {

   607 	        retVal = AllocReadL( R_QTN_SET_BEARER_PACKET_DATA );

   608 	        }

   609 	        break;

   610 	        

   611 	    default:

   612 	        {

   613 	        retVal = CCmPluginBaseEng::GetStringAttributeL( aAttribute );

   614 	        }

   615 	        break;

   616 	    }

   617 	    

   618     return retVal;

   619 	}

   620 

   621 // ----------------------------------------------------------------------------

   622 // CCmPluginPacketData::SetIntAttributeL()

   623 // ----------------------------------------------------------------------------

   624 //

   625 void CCmPluginPacketData::SetIntAttributeL( const TUint32 aAttribute, 

   626                                             TUint32 aValue )

   627 	{

   628     LOGGER_ENTERFN( "CCmPluginPacketData::SetIntAttributeL" );

   629 

   630     switch( aAttribute )

   631         {

   632         default:

   633             {

   634             CCmPluginBaseEng::SetIntAttributeL( aAttribute, aValue );

   635             }

   636         }

   637 	}

   638 

   639 // ----------------------------------------------------------------------------

   640 // CCmPluginPacketData::SetBoolAttributeL()

   641 // ----------------------------------------------------------------------------

   642 //

   643 void CCmPluginPacketData::SetBoolAttributeL( const TUint32 aAttribute, 

   644                                              TBool aValue )

   645 	{

   646     LOGGER_ENTERFN( "CCmPluginPacketData::SetBoolAttributeL" );

   647 

   648     switch( aAttribute )

   649         {

   650         case EPacketDataOutGoing:

   651             {

   652             iOutgoing = aValue;

   653             CreateNewServiceRecordL();

   654             }

   655             break;

   656         

   657         default:

   658             {

   659             CCmPluginBaseEng::SetBoolAttributeL( aAttribute, aValue );

   660             }

   661         }

   662 	}

   663 

   664 // ----------------------------------------------------------------------------

   665 // CCmPluginPacketData::SetStringAttributeL()

   666 // ----------------------------------------------------------------------------

   667 //

   668 void CCmPluginPacketData::SetStringAttributeL( const TUint32 aAttribute, 

   669                                                const TDesC16& aValue )

   670 	{

   671     LOGGER_ENTERFN( "CCmPluginPacketData::SetStringAttributeL" );

   672 

   673     switch( aAttribute )

   674         {

   675         default:

   676             {

   677             CCmPluginBaseEng::SetStringAttributeL( aAttribute, aValue );

   678             }

   679         }

   680 	}

   681 

   682 // ----------------------------------------------------------------------------

   683 // CCmPluginPacketData::PrepareToUpdateRecordsL()

   684 // ----------------------------------------------------------------------------

   685 //

   686 void CCmPluginPacketData::PrepareToUpdateRecordsL()

   687     {

   688     LOGGER_ENTERFN( "CCmPluginPacketData::PrepareToUpdateRecordsL" );

   689 

   690     CheckDNSServerAddressL( ETrue, 

   691                             ServiceRecord().iGPRSIP6NameServer1,

   692                             ServiceRecord().iGPRSIP6NameServer2,

   693                             ServiceRecord().iGPRSIP6DNSAddrFromServer );

   694                             

   695     CheckDNSServerAddressL( EFalse,

   696                             ServiceRecord().iGPRSIPNameServer1,

   697                             ServiceRecord().iGPRSIPNameServer2,

   698                             ServiceRecord().iGPRSIPDNSAddrFromServer );

   699     SetDaemonNameL();

   700     }

   701     

   702 // ----------------------------------------------------------------------------

   703 // CCmPluginPacketData::CanHandleIapIdL()

   704 // ----------------------------------------------------------------------------

   705 //

   706 TBool CCmPluginPacketData::CanHandleIapIdL( TUint32 aIapId ) const

   707     {

   708     LOGGER_ENTERFN( "CCmPluginPacketData::CanHandleIapIdL1" );

   709     CLOG_WRITE_1( "IapId: [%d]", aIapId );

   710     

   711     TBool retVal( EFalse );

   712     

   713     CCDIAPRecord *iapRecord = static_cast<CCDIAPRecord *>

   714                             (CCDRecordBase::RecordFactoryL(KCDTIdIAPRecord));

   715         

   716     CleanupStack::PushL( iapRecord );

   717     iapRecord->SetRecordId( aIapId );

   718     

   719     TRAPD( err, iapRecord->LoadL( Session() ));

   720 

   721     if( !err )

   722         {

   723         CanHandleIapIdL( iapRecord );

   724         }

   725     

   726     CleanupStack::PopAndDestroy( iapRecord );

   727     return retVal;

   728     }

   729 

   730 // ----------------------------------------------------------------------------

   731 // CCmPluginPacketData::CanHandleIapIdL()

   732 // ----------------------------------------------------------------------------

   733 //

   734 TBool CCmPluginPacketData::CanHandleIapIdL( CCDIAPRecord *aIapRecord ) const

   735     {

   736     LOGGER_ENTERFN( "CCmPluginPacketData::CanHandleIapIdL2" );

   737     CLOG_WRITE_1( "IapId: [%d]", aIapRecord->RecordId() );

   738     

   739     TBool retVal( EFalse );

   740     

   741     CLOG_WRITE_2( "IAP record: [%S][%S]",

   742                     &FIELD_TO_TDESC(aIapRecord->iServiceType), 

   743                     &FIELD_TO_TDESC(aIapRecord->iBearerType)

   744                 );

   745     

   746     if( (TPtrC(aIapRecord->iServiceType) == TPtrC(KCDTypeNameOutgoingWCDMA) ||

   747         TPtrC(aIapRecord->iServiceType) == TPtrC(KCDTypeNameIncomingWCDMA)) &&

   748         TPtrC(aIapRecord->iBearerType) == TPtrC(KCDTypeNameModemBearer) )

   749         {

   750         CLOG_WRITE( "I can." );

   751         retVal = ETrue;

   752         }

   753 

   754     return retVal;

   755     }

   756 

   757 // ----------------------------------------------------------------------------

   758 // CCmPluginPacketData::RunSettingsL()

   759 // ----------------------------------------------------------------------------

   760 //        

   761 TInt CCmPluginPacketData::RunSettingsL()

   762 	{

   763     CmPluginPacketDataSettingsDlg* settingsDlg = 

   764                                 CmPluginPacketDataSettingsDlg::NewL( *this );

   765     return settingsDlg->ConstructAndRunLD( );       

   766     }        

   767 

   768 // ----------------------------------------------------------------------------

   769 // CCmPluginPacketData::LoadServiceSettingL()

   770 // ----------------------------------------------------------------------------

   771 //        

   772 void CCmPluginPacketData::LoadServiceSettingL()

   773     {

   774     LOGGER_ENTERFN( "CCmPluginPacketData::LoadServiceSettingL" );

   775     

   776     if( TPtrC(KCDTypeNameOutgoingWCDMA) == iIapRecord->iServiceType  )

   777         {

   778         iServiceRecord = static_cast<CCDServiceRecordBase *>

   779                     (CCDRecordBase::RecordFactoryL(KCDTIdOutgoingGprsRecord));

   780         iOutgoing = ETrue;

   781         }

   782     else if( TPtrC(KCDTypeNameIncomingWCDMA) == iIapRecord->iServiceType )

   783         {

   784         iServiceRecord = static_cast<CCDServiceRecordBase *>

   785                     (CCDRecordBase::RecordFactoryL(KCDTIdIncomingGprsRecord));

   786         iOutgoing = EFalse;

   787         }

   788     else

   789         // this IAP service is not supported by this plugin.

   790         {

   791         User::Leave( KErrNotSupported );

   792         }

   793 

   794     CCmPluginBaseEng::LoadServiceSettingL();

   795 

   796     CLOG_WRITE_1( "APName: [%S]", &FIELD_TO_TDESC( ServiceRecord().iGPRSAPN ) );

   797     }

   798 

   799 // ----------------------------------------------------------------------------

   800 // CCmPluginPacketData::InitializeWithUiL()

   801 // ----------------------------------------------------------------------------

   802 //        

   803 TBool CCmPluginPacketData::InitializeWithUiL( TBool /*aManuallyConfigure*/ )

   804     {

   805     LOGGER_ENTERFN( "CCmPluginPacketData::InitializeWithUiL" );    

   806     TBool retval = ETrue;   // meaning that everything was fine.

   807 

   808     // Add resource file for the duration of this method only.

   809     TParse parser;

   810     User::LeaveIfError( parser.Set( KPluginPacketDataResDirAndFileName, 

   811                                     &KDC_RESOURCE_FILES_DIR, 

   812                                     NULL ) );

   813 

   814     TFileName resourceFileNameBuf = parser.FullName();

   815 

   816     RConeResourceLoader resLoader( *CEikonEnv::Static() ) ;

   817     resLoader.OpenL( resourceFileNameBuf );

   818     CleanupClosePushL( resLoader );

   819 

   820     // Show dialog

   821     TBuf<KMaxGprsApNameLength> buf;

   822     CAknTextQueryDialog* dlg = new (ELeave) CAknTextQueryDialog( buf );

   823 

   824     // Must use PrepareLC instead of ExecuteLD in order for

   825     // MakeLeftSoftkeyVisible() call to work.

   826     dlg->PrepareLC( R_APN_NAME_QUERY );

   827 

   828     dlg->SetMaxLength( KMaxGprsApNameLength );

   829     dlg->MakeLeftSoftkeyVisible( ETrue );   // Empty input accepted.

   830 

   831     HBufC* prompt = StringLoader::LoadLC( R_GPRS_PLUGIN_APN_PROMPT );

   832     dlg->SetPromptL( *prompt );

   833     CleanupStack::PopAndDestroy( prompt );

   834 

   835     // Strange, but true: RunLD returns 0 (instead of the actual command id)

   836     // if Cancel button was pressed, thus we have to check against zero here.

   837     if ( dlg->RunLD() )

   838         {

   839         // Change APN attribute in connection method

   840         SetStringAttributeL( EPacketDataAPName, buf );

   841         

   842         if( buf.Length() )

   843             {

   844             SetStringAttributeL( ECmName, buf );

   845             }

   846         }

   847     else

   848         {

   849         retval = EFalse;    // indicating cancellation.

   850         }

   851 

   852     // Clean-up

   853     CleanupStack::PopAndDestroy( &resLoader );

   854 

   855     return retval;

   856     }

   857 

   858 

   859 // ----------------------------------------------------------------------------

   860 // CCmPluginPacketData::ServiceRecord()

   861 // ----------------------------------------------------------------------------

   862 //        

   863 CCDWCDMAPacketServiceRecord& CCmPluginPacketData::ServiceRecord() const

   864     {

   865     LOGGER_ENTERFN( "CCmPluginPacketData::ServiceRecord" );

   866 

   867     return *static_cast<CCDWCDMAPacketServiceRecord*>(iServiceRecord);

   868     }

   869     

   870 // ----------------------------------------------------------------------------

   871 // CCmPluginPacketData::CreateNewServiceRecordL()

   872 // ----------------------------------------------------------------------------

   873 //        

   874 void CCmPluginPacketData::CreateNewServiceRecordL()

   875     {

   876     LOGGER_ENTERFN( "CCmPluginPacketData::CreateNewServiceRecordL" );

   877 

   878     delete iServiceRecord; iServiceRecord = NULL;

   879     

   880     if( iOutgoing )

   881         {

   882         iServiceRecord = static_cast<CCDServiceRecordBase *>

   883                     (CCDRecordBase::RecordFactoryL(KCDTIdOutgoingGprsRecord));

   884         }

   885     else

   886         {

   887         iServiceRecord = static_cast<CCDServiceRecordBase *>

   888                     (CCDRecordBase::RecordFactoryL(KCDTIdIncomingGprsRecord));

   889         }

   890 

   891     ServiceRecord().iGPRSAPN.SetL( KNullDesC );

   892     ServiceRecord().iGPRSPDPType.SetL( RPacketContext::EPdpTypeIPv4 );

   893     ServiceRecord().iGPRSReqPrecedence = 0;

   894 	ServiceRecord().iGPRSReqDelay = 0;

   895 	ServiceRecord().iGPRSReqReliability = 0;

   896 	ServiceRecord().iGPRSReqPeakThroughput = 0;

   897 	ServiceRecord().iGPRSReqMeanThroughput = 0;

   898 	ServiceRecord().iGPRSMinPrecedence = 0;

   899 	ServiceRecord().iGPRSMinDelay = 0;

   900 	ServiceRecord().iGPRSMinReliability = 0;

   901 	ServiceRecord().iGPRSMinPeakThroughput = 0;

   902 	ServiceRecord().iGPRSMinMeanThroughput = 0;

   903 	ServiceRecord().iGPRSDataCompression = 0;

   904 	ServiceRecord().iGPRSHeaderCompression = 0;

   905 	ServiceRecord().iGPRSAnonymousAccess = 0;

   906     ServiceRecord().iGPRSIfNetworks.SetL( KDefIspIfNetworksIPv4 );

   907     ServiceRecord().iGPRSIfPromptForAuth = EFalse;

   908     ServiceRecord().iGPRSIfAuthRetries = 0;

   909     ServiceRecord().iGPRSIPGateway.SetL( KUnspecifiedIPv4 );

   910     ServiceRecord().iGPRSIPAddrFromServer = ETrue;

   911     ServiceRecord().iGPRSIPAddr.SetL( KUnspecifiedIPv4 );

   912     ServiceRecord().iGPRSIPDNSAddrFromServer = ETrue;

   913     ServiceRecord().iGPRSIPNameServer1.SetL( KUnspecifiedIPv4 );

   914     ServiceRecord().iGPRSIPNameServer2.SetL( KUnspecifiedIPv4 );

   915     ServiceRecord().iGPRSIP6DNSAddrFromServer = ETrue;

   916     ServiceRecord().iGPRSIP6NameServer1.SetL( KDynamicIpv6Address );

   917     ServiceRecord().iGPRSIP6NameServer2.SetL( KDynamicIpv6Address );

   918     ServiceRecord().iGPRSEnableLCPExtension = EFalse;

   919     ServiceRecord().iGPRSDisablePlainTextAuth = ETrue;

   920     ServiceRecord().iGPRSAPType = EPacketDataBoth;

   921     ServiceRecord().iGPRSQOSWarningTimeOut = TUint32(-1);

   922     }

   923 

   924 // ----------------------------------------------------------------------------

   925 // CCmPluginPacketData::ServiceRecordIdLC

   926 // ----------------------------------------------------------------------------

   927 //

   928 void CCmPluginPacketData::ServiceRecordIdLC( HBufC* &aName, 

   929                                              TUint32& aRecordId )

   930     {

   931     LOGGER_ENTERFN( "CCmPluginPacketData::ServiceRecordIdLC" );

   932 

   933     if( iOutgoing )

   934         {

   935         aName = TPtrC( KCDTypeNameOutgoingWCDMA ).AllocLC();

   936         }

   937     else

   938         {

   939         aName = TPtrC( KCDTypeNameIncomingWCDMA ).AllocLC();

   940         }

   941         

   942     aRecordId = iServiceRecord->RecordId();

   943     }

   944 

   945 // ----------------------------------------------------------------------------

   946 // CCmPluginPacketData::BearerRecordIdLC()

   947 // ----------------------------------------------------------------------------

   948 //        

   949 void CCmPluginPacketData::BearerRecordIdLC( HBufC* &aBearerName, 

   950                                             TUint32& aRecordId )

   951     {

   952     LOGGER_ENTERFN( "CCmPluginPacketData::BearerRecordIdLC" );

   953 

   954 	CMDBRecordSet<CCDModemBearerRecord>* bearerRS = 

   955 	        new(ELeave) CMDBRecordSet<CCDModemBearerRecord>(KCDTIdModemBearerRecord);

   956 	CleanupStack::PushL( bearerRS );

   957     

   958     CCDModemBearerRecord* bearerRecord = static_cast<CCDModemBearerRecord *>

   959                             (CCDRecordBase::RecordFactoryL(KCDTIdModemBearerRecord));

   960                                     

   961     CleanupStack::PushL( bearerRecord );

   962     

   963     bearerRecord->iRecordName.SetL( KModemBearerPacketData );

   964     bearerRS->iRecords.AppendL( bearerRecord );

   965     CleanupStack::Pop( bearerRecord );

   966     

   967     if( bearerRS->FindL( Session() ) )

   968         {

   969         CLOG_WRITE_1( "Bearers: [%d]", bearerRS->iRecords.Count() );

   970 

   971         bearerRecord = static_cast<CCDModemBearerRecord*>(bearerRS->iRecords[0]);

   972         aRecordId = bearerRecord->RecordId();

   973         }

   974     else

   975         // bearer not found -> create dummy values

   976         {

   977         CLOG_WRITE( "No bearer record found" );

   978 

   979         bearerRecord->SetRecordId( KCDNewRecordRequest );

   980         bearerRecord->StoreL( Session() );

   981         

   982         aRecordId = bearerRecord->RecordId();

   983         }

   984 

   985     CleanupStack::PopAndDestroy( bearerRS );

   986 

   987     aBearerName = TPtrC(KCDTypeNameModemBearer).AllocLC();

   988     }

   989 

   990 // ----------------------------------------------------------------------------

   991 // CCmPluginPacketData::CheckNetworkCoverageL()

   992 // ----------------------------------------------------------------------------

   993 //        

   994 TBool CCmPluginPacketData::CheckNetworkCoverageL() const

   995     {

   996     LOGGER_ENTERFN("CCmPluginPacketData::CheckNetworkCoverageL");

   997     

   998     TBool retVal( EFalse );

   999     

  1000 #ifdef __WINS__

  1001     retVal = ETrue;

  1002 #else

  1003     CCmPDCoverageCheck* coverage = new (ELeave) CCmPDCoverageCheck;

  1004     CleanupStack::PushL( coverage );

  1005     

  1006     retVal = coverage->IsThereCoverageL();

  1007     

  1008     CleanupStack::PopAndDestroy( coverage );

  1009     

  1010 #endif  // __WINS

  1011     return retVal;

  1012     }

  1013 

  1014 // ----------------------------------------------------------------------------

  1015 // CCmPluginPacketData::SetPDPTypeL()

  1016 // ----------------------------------------------------------------------------

  1017 //        

  1018 void CCmPluginPacketData::SetPDPTypeL( RPacketContext::TProtocolType aPdpType )

  1019     {

  1020     LOGGER_ENTERFN( "CCmPluginPacketData::SetPDPTypeL" );

  1021 

  1022     if( aPdpType != RPacketContext::EPdpTypeIPv4 &&

  1023         aPdpType != RPacketContext::EPdpTypeIPv6 )

  1024         {

  1025         User::Leave( KErrArgument );

  1026         }

  1027         

  1028     if( FeatureSupported( KFeatureIdIPv6 ) && aPdpType == 

  1029         RPacketContext::EPdpTypeIPv6 )

  1030         {

  1031         ServiceRecord().iGPRSPDPType = RPacketContext::EPdpTypeIPv6;

  1032         ServiceRecord().iGPRSIfNetworks.SetL( KDefIspIfNetworksIPv6 );

  1033         }

  1034     else

  1035         {

  1036         if( aPdpType == RPacketContext::EPdpTypeIPv6 )

  1037             {

  1038             User::Leave( KErrNotSupported );

  1039             }

  1040             

  1041         ServiceRecord().iGPRSIfNetworks.SetL( KDefIspIfNetworksIPv4 );

  1042         ServiceRecord().iGPRSPDPType = RPacketContext::EPdpTypeIPv4;

  1043         }

  1044     }

  1045     

  1046 // ----------------------------------------------------------------------------

  1047 // CCmPluginPacketData::AdditionalReset()

  1048 // ----------------------------------------------------------------------------

  1049 //        

  1050 void CCmPluginPacketData::AdditionalReset()

  1051     {

  1052     LOGGER_ENTERFN( "CCmPluginPacketData::AdditionalReset" );

  1053 

  1054     delete iPacketDataQoSRecord;

  1055     iPacketDataQoSRecord = NULL;

  1056     }

  1057 

  1058 // ---------------------------------------------------------------------------

  1059 // CCmPluginPacketData::PrepareToCopyDataL

  1060 // ---------------------------------------------------------------------------

  1061 //

  1062 void CCmPluginPacketData::PrepareToCopyDataL( CCmPluginBaseEng* aDestInst ) const

  1063     {

  1064     LOGGER_ENTERFN( "CCmPluginPacketData::PrepareToCopyDataL" );

  1065 

  1066     aDestInst->SetBoolAttributeL( EPacketDataOutGoing, iOutgoing );

  1067     }

  1068 

  1069 

  1070 // ---------------------------------------------------------------------------

  1071 // CCmPluginPacketData::SetDaemonNameL

  1072 // ---------------------------------------------------------------------------

  1073 //

  1074 void CCmPluginPacketData::SetDaemonNameL()

  1075     {

  1076     LOGGER_ENTERFN( "CCmPluginPacketData::SetDaemonNameL" );

  1077 

  1078     // use DHCP if we can

  1079     TBool ipfromSrv = GetBoolAttributeL( ECmIPAddFromServer );

  1080     if ( ipfromSrv )

  1081         {

  1082         SetStringAttributeL( ECmConfigDaemonManagerName, 

  1083                            KDaemonManagerName );

  1084         SetStringAttributeL( ECmConfigDaemonName, 

  1085                            KConfigDaemonName );

  1086         }

  1087     else

  1088         {

  1089         if ( FeatureSupported( KFeatureIdIPv6 ) )

  1090             {

  1091             SetStringAttributeL( ECmConfigDaemonManagerName, 

  1092                                KDaemonManagerName );

  1093             SetStringAttributeL( ECmConfigDaemonName, 

  1094                                KConfigDaemonName );

  1095             }

  1096         else

  1097             {

  1098             SetStringAttributeL( ECmConfigDaemonManagerName, 

  1099                                KNullDesC() );

  1100             SetStringAttributeL( ECmConfigDaemonName, 

  1101                                KNullDesC() );

  1102             }

  1103         }

  1104     }

  1105 

  1106 

  1107 // ---------------------------------------------------------------------------

  1108 // CCmPluginPacketData::CreateAdditionalRecordsL

  1109 // ---------------------------------------------------------------------------

  1110 //

  1111 void CCmPluginPacketData::CreateAdditionalRecordsL()

  1112     {

  1113     LOGGER_ENTERFN( "CCmPluginPacketData::CreateAdditionalRecordsL" );

  1114 

  1115     delete iPacketDataQoSRecord;

  1116     iPacketDataQoSRecord = NULL;

  1117 

  1118     iPacketDataQoSRecord = static_cast<CCDUmtsR99QoSAndOnTableRecord *>

  1119                            (CCDRecordBase::RecordFactoryL(KCDTIdUmtsR99QoSAndOnTableRecord));

  1120 

  1121     iPacketDataQoSRecord->iGPRSReqTrafficClass = RPacketQoS::ETrafficClassUnspecified;

  1122     iPacketDataQoSRecord->iGPRSMinTrafficClass = RPacketQoS::ETrafficClassUnspecified;

  1123     iPacketDataQoSRecord->iGPRSReqDeliveryOrder = RPacketQoS::EDeliveryOrderUnspecified;

  1124     iPacketDataQoSRecord->iGPRSMinDeliveryOrder = RPacketQoS::EDeliveryOrderUnspecified;

  1125     iPacketDataQoSRecord->iGPRSReqDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryUnspecified;

  1126     iPacketDataQoSRecord->iGPRSMinDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryUnspecified;

  1127     iPacketDataQoSRecord->iGPRSReqMaxSDUSize = 0;

  1128     iPacketDataQoSRecord->iGPRSMinAcceptableMaxSDUSize = 0;

  1129     iPacketDataQoSRecord->iGPRSReqMaxUplinkRate = 0;

  1130     iPacketDataQoSRecord->iGPRSReqMinUplinkRate = 0;

  1131     iPacketDataQoSRecord->iGPRSReqMaxDownlinkRate = 0;

  1132     iPacketDataQoSRecord->iGPRSReqMinDownlinkRate = 0;

  1133     iPacketDataQoSRecord->iGPRSReqBER = RPacketQoS::EBERUnspecified;