Mercurial Mercurial > oss > FCL > sf > mw > ipconnmgmt / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
cmmanager/cmmgr/cmmpluginbase/src/ccmpluginbaseeng.cpp
changeset 27 489cf6208544
parent 23 7ec726f93df1
child 32 5c4486441ae6
child 46 95d45f234cf3
equal deleted inserted replaced
23:7ec726f93df1 27:489cf6208544 
    18 
    18 
    19 
    19 
    20 #include <datamobilitycommsdattypes.h>
 
    20 #include <datamobilitycommsdattypes.h>
 
    21 #include <cmpluginbaseeng.h>
 
    21 #include <cmpluginbaseeng.h>
 
    22 #include <cmpsettingsconsts.h>
 
    22 #include <cmpsettingsconsts.h>
 
    23 #include <FeatMgr.h>
 
    23 #include <featmgr.h>
 
    24 
    24 
    25 #include "ccmpluginbaseengtextresolver.h"
 
    25 #include "ccmpluginbaseengtextresolver.h"
 
    26 
    26 
    27 #include "OstTraceDefinitions.h"
 
    27 #include "OstTraceDefinitions.h"
 
    28 #ifdef OST_TRACE_COMPILER_IN_USE
 
    28 #ifdef OST_TRACE_COMPILER_IN_USE
 
    92 // Second phase constructor.
 
    92 // Second phase constructor.
 
    93 // ---------------------------------------------------------------------------
 
    93 // ---------------------------------------------------------------------------
 
    94 //
 
    94 //
 
    95 void CCmClientPluginInstance::ConstructL()
 
    95 void CCmClientPluginInstance::ConstructL()
 
    96     {
 
    96     {
 
    97     OstTraceFunctionEntry0( CCMCLIENTPLUGININSTANCE_CONSTRUCTL_ENTRY );
 
       
    98     OstTraceFunctionExit0( CCMCLIENTPLUGININSTANCE_CONSTRUCTL_EXIT );
 
       
    99     }
 
    97     }
 
   100 
    98 
   101 
    99 
   102 // ---------------------------------------------------------------------------
 
   100 // ---------------------------------------------------------------------------
 
   103 // TCmPluginInitParam::TCmPluginInitParam
 
   101 // TCmPluginInitParam::TCmPluginInitParam
 
   329         // we already have IAP id ->
 
   327         // we already have IAP id ->
 
   330         {
 
   328         {
 
   331         User::Leave( KErrAlreadyExists );
 
   329         User::Leave( KErrAlreadyExists );
 
   332         }
 
   330         }
 
   333 
   331 
   334     // optional record is disabled in default
 
   332     // Optional record, disabled by default.
 
   335     iLocationEnabled = EFalse;
 
   333     iLocationEnabled = EFalse;
 
   336 
   334 
   337     // create mandatory records
 
   335     // Create mandatory records.
 
   338     iIapRecord = static_cast<CCDIAPRecord *>
 
   336     iIapRecord = static_cast<CCDIAPRecord*>(
 
   339                           (CCDRecordBase::RecordFactoryL(KCDTIdIAPRecord));
 
   337             CCDRecordBase::RecordFactoryL( KCDTIdIAPRecord ) );
 
   340     iNetworkRecord = static_cast<CCDNetworkRecord *>
 
   338     iNetworkRecord = static_cast<CCDNetworkRecord*>(
 
   341                           (CCDRecordBase::RecordFactoryL(KCDTIdNetworkRecord));
 
   339             CCDRecordBase::RecordFactoryL( KCDTIdNetworkRecord ) );
 
   342     iProxyRecord = static_cast<CCDProxiesRecord *>
 
   340     iProxyRecord = static_cast<CCDProxiesRecord*>(
 
   343                   (CCDRecordBase::RecordFactoryL(KCDTIdProxiesRecord));
 
   341             CCDRecordBase::RecordFactoryL( KCDTIdProxiesRecord ) );
 
   344     NewWapRecordL();
 
   342     NewWapRecordL();
 
   345     iWapIPBearerRecord->iWAPGatewayAddress.SetL( KDefWapGatewayIpAddress );
 
   343     iWapIPBearerRecord->iWAPGatewayAddress.SetL( KDefWapGatewayIpAddress );
 
   346 
   344 
   347     iMetaDataRecord = NewMetadataRecordL( ETrue );
 
   345     iMetaDataRecord = NewMetadataRecordL( ETrue );
 
   348 
   346 
   349     // call plugin to create its own records
 
   347     // Call plugin to create its own records.
 
   350     CreateServiceRecordL();
 
   348     CreateServiceRecordL();
 
   351 
   349 
   352     // Update iaprecord servicetype name
 
   350     // Update iaprecord servicetype name.
 
   353     HBufC* servicetypeName( NULL );
 
   351     HBufC* servicetypeName( NULL );
 
   354     ServiceRecordNameLC( servicetypeName );
 
   352     ServiceRecordNameLC( servicetypeName );
 
   355     iIapRecord->iServiceType.SetL( *servicetypeName );
 
   353     iIapRecord->iServiceType.SetL( *servicetypeName );
 
   356     CleanupStack::PopAndDestroy( servicetypeName );
 
   354     CleanupStack::PopAndDestroy( servicetypeName );
 
   357 
   355 
   358     // Update iaprecord bearertype name
 
   356     // Update iaprecord bearertype name.
 
   359     HBufC* bearerTypeName( NULL );
 
   357     HBufC* bearerTypeName( NULL );
 
   360     BearerRecordNameLC( bearerTypeName );
 
   358     BearerRecordNameLC( bearerTypeName );
 
   361     iIapRecord->iBearerType.SetL( *bearerTypeName );
 
   359     iIapRecord->iBearerType.SetL( *bearerTypeName );
 
   362     CleanupStack::PopAndDestroy( bearerTypeName );
 
   360     CleanupStack::PopAndDestroy( bearerTypeName );
 
   363 
   361 
   364     CreateBearerRecordsL();
 
   362     CreateBearerRecordsL();
 
   365 
   363 
   366     EnableProxyL( EFalse );
 
   364     EnableProxyL( EFalse );
 
   367 
   365 
   368     _LIT(KDefaultConnNameTextId, "txt_occ_setlabel_connection_name_val_connection");
 
   366     _LIT( KDefaultConnNameTextId, "txt_occ_setlabel_connection_name_val_connection" );
 
   369     HBufC* resolvedText( NULL );
 
   367     HBufC* resolvedText( NULL );
 
   370     resolvedText = CCmPluginBaseEngTextResolver::ResolveTextL( KDefaultConnNameTextId );
 
   368     resolvedText = CCmPluginBaseEngTextResolver::ResolveTextL( KDefaultConnNameTextId );
 
   371     if ( resolvedText != NULL )
 
   369     if ( resolvedText != NULL )
 
   372         {
 
   370         {
 
   373         SetDefaultNameL( *resolvedText );
 
   371         SetDefaultNameL( *resolvedText );
 
   398 // ---------------------------------------------------------------------------
 
   396 // ---------------------------------------------------------------------------
 
   399 // CCmPluginBaseEng::CreateCopyL
 
   397 // CCmPluginBaseEng::CreateCopyL
 
   400 // ---------------------------------------------------------------------------
 
   398 // ---------------------------------------------------------------------------
 
   401 //
 
   399 //
 
   402 EXPORT_C CCmPluginBaseEng* CCmPluginBaseEng::CreateCopyL(
 
   400 EXPORT_C CCmPluginBaseEng* CCmPluginBaseEng::CreateCopyL(
 
   403     CCmClientPluginInstance* /*aClientPluginInstance*/ )
 
   401         CCmClientPluginInstance* /*aClientPluginInstance*/ )
 
   404     {
 
   402     {
 
   405     OstTraceFunctionEntry0( CCMPLUGINBASEENG_CREATECOPYL_ENTRY );
 
   403     OstTraceFunctionEntry0( CCMPLUGINBASEENG_CREATECOPYL_ENTRY );
 
   406 
   404 
   407     TCmPluginInitParam params( iSession );
 
   405     TCmPluginInitParam params( iSession );
 
   408 
       
   409     CCmPluginBaseEng* copyInst = CreateInstanceL( params );
 
   406     CCmPluginBaseEng* copyInst = CreateInstanceL( params );
 
   410     CleanupStack::PushL( copyInst );
 
   407     CleanupStack::PushL( copyInst );
 
   411 
   408 
   412     PrepareToCopyDataL( copyInst );
 
   409     PrepareToCopyDataL( copyInst );
 
   413 
       
   414     CopyDataL( copyInst );
 
   410     CopyDataL( copyInst );
 
   415 
       
   416     CleanupStack::Pop( copyInst );
 
   411     CleanupStack::Pop( copyInst );
 
   417 
   412 
   418     OstTraceFunctionExit0( CCMPLUGINBASEENG_CREATECOPYL_EXIT );
 
   413     OstTraceFunctionExit0( CCMPLUGINBASEENG_CREATECOPYL_EXIT );
 
   419 
       
   420     return copyInst;
 
   414     return copyInst;
 
   421     }
 
   415     }
 
   422 
   416 
   423 // ---------------------------------------------------------------------------
 
   417 // ---------------------------------------------------------------------------
 
   424 // CCmPluginBaseEng::GetGenericTableIdsToBeObserved
 
   418 // CCmPluginBaseEng::GetGenericTableIdsToBeObserved
 
   425 // ---------------------------------------------------------------------------
 
   419 // ---------------------------------------------------------------------------
 
   426 //
 
   420 //
 
   427 EXPORT_C void CCmPluginBaseEng::GetGenericTableIdsToBeObserved(
 
   421 EXPORT_C void CCmPluginBaseEng::GetGenericTableIdsToBeObserved(
 
   428         RArray<TUint32>& aTableIdArray ) const
 
   422         RArray<TUint32>& aTableIdArray ) const
 
   429     {
 
   423     {
 
   430     // Service and bearer records should be added by plugins
 
   424     // Service and bearer records should be added by plugins.
 
   431 
   425 
   432     aTableIdArray.Append( KCDTIdIAPRecord );
 
   426     aTableIdArray.Append( KCDTIdIAPRecord );
 
   433     aTableIdArray.Append( KCDTIdWAPAccessPointRecord );
 
   427     aTableIdArray.Append( KCDTIdWAPAccessPointRecord );
 
   434     aTableIdArray.Append( KCDTIdProxiesRecord );
 
   428     aTableIdArray.Append( KCDTIdProxiesRecord );
 
   435     aTableIdArray.Append( iMetadataTableId );
 
   429     aTableIdArray.Append( iMetadataTableId );
 
   458     {
 
   452     {
 
   459     OstTraceFunctionEntry0( CCMPLUGINBASEENG_COPYRECORDSL_ENTRY );
 
   453     OstTraceFunctionEntry0( CCMPLUGINBASEENG_COPYRECORDSL_ENTRY );
 
   460 
   454 
   461     CopyRecordDataL( KIapRecordIndex, aCopyInstance );
 
   455     CopyRecordDataL( KIapRecordIndex, aCopyInstance );
 
   462 
   456 
   463     // Ensure that iap's name is set by the rules(Naming Method)
 
   457     // Ensure that IAP's name is set by the rules (Naming Method).
 
   464     SetNameL( iIapRecord->iRecordName.GetL(),
 
   458     SetNameL(
 
   465               aCopyInstance->iIapRecord,
 
   459             iIapRecord->iRecordName.GetL(),
 
   466               aCopyInstance->iNamingMethod );
 
   460             aCopyInstance->iIapRecord,
 
       
   461             aCopyInstance->iNamingMethod );
 
   467 
   462 
   468     CopyRecordDataL( KServiceRecordIndex, aCopyInstance );
 
   463     CopyRecordDataL( KServiceRecordIndex, aCopyInstance );
 
   469     CopyRecordDataL( KNetworkRecordIndex, aCopyInstance );
 
   464     CopyRecordDataL( KNetworkRecordIndex, aCopyInstance );
 
   470     CopyRecordDataL( KWAPAPRecordIndex, aCopyInstance );
 
   465     CopyRecordDataL( KWAPAPRecordIndex, aCopyInstance );
 
   471     CopyRecordDataL( KWAPBearerRecordIndex, aCopyInstance );
 
   466     CopyRecordDataL( KWAPBearerRecordIndex, aCopyInstance );
 
   472     CopyRecordDataL( KMetaDataRecordIndex, aCopyInstance );
 
   467     CopyRecordDataL( KMetaDataRecordIndex, aCopyInstance );
 
   473     CopyRecordDataL( KLocationRecordIndex, aCopyInstance );
 
       
   474     CopyRecordDataL( KProxyRecordIndex, aCopyInstance );
 
   468     CopyRecordDataL( KProxyRecordIndex, aCopyInstance );
 
   475 
   469 
   476     CopyBearerRecordsL( aCopyInstance );
 
   470     CopyBearerRecordsL( aCopyInstance );
 
   477 
   471 
   478     OstTraceFunctionExit0( CCMPLUGINBASEENG_COPYRECORDSL_EXIT );
 
   472     OstTraceFunctionExit0( CCMPLUGINBASEENG_COPYRECORDSL_EXIT );
 
   497             }
 
   491             }
 
   498             break;
 
   492             break;
 
   499         case KServiceRecordIndex:
 
   493         case KServiceRecordIndex:
 
   500             {
 
   494             {
 
   501             aCopyInstance->iServiceRecord = CopyServiceRecordL();
 
   495             aCopyInstance->iServiceRecord = CopyServiceRecordL();
 
       
   496             // The name of the service record copy is changed during update
 
       
   497             // process, in PrepareToUpdateRecordsL()-method.
 
   502             }
 
   498             }
 
   503             break;
 
   499             break;
 
   504         case KNetworkRecordIndex:
 
   500         case KNetworkRecordIndex:
 
   505             {
 
   501             {
 
   506             aCopyInstance->iNetworkRecord = static_cast<CCDNetworkRecord*>(
 
   502             aCopyInstance->iNetworkRecord = static_cast<CCDNetworkRecord*>(
 
   519                     CCDRecordBase::CreateCopyRecordL( *iWapIPBearerRecord ) );
 
   515                     CCDRecordBase::CreateCopyRecordL( *iWapIPBearerRecord ) );
 
   520             }
 
   516             }
 
   521             break;
 
   517             break;
 
   522         case KMetaDataRecordIndex:
 
   518         case KMetaDataRecordIndex:
 
   523             {
 
   519             {
 
   524             aCopyInstance->iMetaDataRecord =
 
   520             CCDIAPMetadataRecord* metadataRecord =
 
   525                     new( ELeave ) CCDIAPMetadataRecord( iMetadataTableId );
 
   521                     new( ELeave ) CCDIAPMetadataRecord( iMetadataTableId );
 
   526             aCopyInstance->iMetaDataRecord->iIAP = IAPRecordElementId();
 
   522             CleanupStack::PushL( metadataRecord );
 
   527             aCopyInstance->iMetaDataRecord->iMetadata.SetL( iMetaDataRecord->iMetadata );
 
   523             CopyRecordFieldsL( *iMetaDataRecord, *metadataRecord );
 
   528             aCopyInstance->iMetaDataRecord->iSeamlessness.SetL( iMetaDataRecord->iSeamlessness );
 
   524             CleanupStack::Pop( metadataRecord );
 
   529             }
 
   525             aCopyInstance->iMetaDataRecord = metadataRecord;
 
   530             break;
 
       
   531         case KLocationRecordIndex:
 
       
   532             {
 
       
   533             aCopyInstance->iWapIPBearerRecord =
 
       
   534                     static_cast<CCDWAPIPBearerRecord*>
 
       
   535                         ( CCDRecordBase::CreateCopyRecordL( *iWapIPBearerRecord ) );
 
       
   536             }
 
   526             }
 
   537             break;
 
   527             break;
 
   538         case KProxyRecordIndex:
 
   528         case KProxyRecordIndex:
 
   539             {
 
   529             {
 
   540             if ( iProxyRecord )
 
   530             if ( iProxyRecord )
 
   550             }
 
   540             }
 
   551             break;
 
   541             break;
 
   552         }
 
   542         }
 
   553 
   543 
   554     OstTraceFunctionExit0( CCMPLUGINBASEENG_COPYRECORDDATAL_EXIT );
 
   544     OstTraceFunctionExit0( CCMPLUGINBASEENG_COPYRECORDDATAL_EXIT );
 
       
   545     }
 
       
   546 
       
   547 // ---------------------------------------------------------------------------
 
       
   548 // CCmPluginBaseEng:: CopyRecordFieldsL
 
       
   549 // ---------------------------------------------------------------------------
 
       
   550 //
 
       
   551 void CCmPluginBaseEng::CopyRecordFieldsL(
 
       
   552         CommsDat::CMDBRecordBase& aSource,
 
       
   553         CommsDat::CMDBRecordBase& aDestination )
 
       
   554     {
 
       
   555     OstTraceFunctionEntry0( CCMPLUGINBASEENG_COPYRECORDFIELDSL_ENTRY );
 
       
   556 
       
   557     const SRecordTypeInfo* recordInfo = aSource.GetRecordInfo();
 
       
   558     if ( recordInfo == NULL )
 
       
   559         {
 
       
   560         User::Leave( KErrCorrupt );
 
       
   561         }
 
       
   562 
       
   563     CMDBElement* ptrSource( NULL );
 
       
   564     CMDBElement* ptrDest( NULL );
 
       
   565 
       
   566     while ( recordInfo != NULL && recordInfo->iTypeId != 0 )
 
       
   567         {
 
       
   568         ptrSource = aSource.GetFieldByIdL( recordInfo->iTypeId );
 
       
   569         ptrDest = aDestination.GetFieldByIdL( recordInfo->iTypeId );
 
       
   570 
       
   571         // Make sure we see only basic type info. Masks out any additional info
 
       
   572         // on links (CommsDat internal stuff).
 
       
   573         switch ( recordInfo->iValType & 0x000000ff )
 
       
   574             {
 
       
   575             case CommsDat::EInt:
 
       
   576             case CommsDat::EBool:
 
       
   577                 {
 
       
   578                 if ( !( ptrSource->IsNull() ) )
 
       
   579                     {
 
       
   580                     static_cast<CMDBField<TInt>&>( *ptrDest ).SetL(
 
       
   581                             static_cast<CMDBField<TInt>&>( *ptrSource ) );
 
       
   582                     }
 
       
   583                 }
 
       
   584                 break;
 
       
   585             case CommsDat::EUint32:
 
       
   586             case CommsDat::ELink:
 
       
   587                 {
 
       
   588                 if ( !( ptrSource->IsNull() ) )
 
       
   589                     {
 
       
   590                     static_cast<CMDBField<TUint32>&>( *ptrDest ).SetL(
 
       
   591                             static_cast<CMDBField<TUint32>&>( *ptrSource ) );
 
       
   592                     }
 
       
   593                 }
 
       
   594                 break;
 
       
   595             case CommsDat::EDesC8:
 
       
   596                 {
 
       
   597                 if ( !( ptrSource->IsNull() ) )
 
       
   598                     {
 
       
   599                     static_cast<CMDBField<TDesC8>&>( *ptrDest ).SetL(
 
       
   600                             static_cast<CMDBField<TDesC8>&>( *ptrSource ) );
 
       
   601                     }
 
       
   602                 }
 
       
   603                 break;
 
       
   604             case CommsDat::EText:
 
       
   605             case CommsDat::EMedText:
 
       
   606             case CommsDat::ELongText:
 
       
   607                 {
 
       
   608                 if ( !( ptrSource->IsNull() ) )
 
       
   609                     {
 
       
   610                     static_cast<CMDBField<TDesC>&>( *ptrDest ).SetL(
 
       
   611                             static_cast<CMDBField<TDesC>&>( *ptrSource ) );
 
       
   612                     }
 
       
   613                 }
 
       
   614                 break;
 
       
   615             default:
 
       
   616                 {
 
       
   617                 User::Leave( KErrCorrupt );
 
       
   618                 }
 
       
   619                 break;
 
       
   620             }
 
       
   621         ptrDest->SetAttributes( ptrSource->Attributes() );
 
       
   622         recordInfo++;
 
       
   623         }
 
       
   624 
       
   625     OstTraceFunctionExit0( CCMPLUGINBASEENG_COPYRECORDFIELDSL_EXIT );
 
   555     }
 
   626     }
 
   556 
   627 
   557 // ---------------------------------------------------------------------------
 
   628 // ---------------------------------------------------------------------------
 
   558 // CCmPluginBaseEng::DoLoadL
 
   629 // CCmPluginBaseEng::DoLoadL
 
   559 // ---------------------------------------------------------------------------
 
   630 // ---------------------------------------------------------------------------
 
   566 
   637 
   567     LoadIAPRecordL( aIapId );
 
   638     LoadIAPRecordL( aIapId );
 
   568     LoadWapRecordL();
 
   639     LoadWapRecordL();
 
   569     LoadMetadataRecordL();
 
   640     LoadMetadataRecordL();
 
   570     LoadNetworkRecordL();
 
   641     LoadNetworkRecordL();
 
   571     LoadLocationRecordL();
 
       
   572 
   642 
   573     // This is a connectionmethodinfo instance, that has no
 
   643     // This is a connectionmethodinfo instance, that has no
 
   574     // service and proxy setting.
 
   644     // service and proxy setting.
 
   575     if ( KDummyBearerType != iBearerType )
 
   645     if ( KDummyBearerType != iBearerType )
 
   576         {
 
   646         {
 
   635             new( ELeave ) CMDBRecordSet<CCDProxiesRecord>( KCDTIdProxiesRecord );
 
   705             new( ELeave ) CMDBRecordSet<CCDProxiesRecord>( KCDTIdProxiesRecord );
 
   636     CleanupStack::PushL(proxieRS);
 
   706     CleanupStack::PushL(proxieRS);
 
   637 
   707 
   638     // Now try to find the linked proxy record
 
   708     // Now try to find the linked proxy record
 
   639     // create new record
 
   709     // create new record
 
   640     CCDProxiesRecord* proxyRecord = static_cast<CCDProxiesRecord *>(
 
   710     CCDProxiesRecord* proxyRecord = static_cast<CCDProxiesRecord*>(
 
   641             CCDRecordBase::RecordFactoryL( KCDTIdProxiesRecord ) );
 
   711             CCDRecordBase::RecordFactoryL( KCDTIdProxiesRecord ) );
 
   642 
   712 
   643     CleanupStack::PushL( proxyRecord );
 
   713     CleanupStack::PushL( proxyRecord );
 
   644 
   714 
   645     // Prime record
 
   715     // Prime record
 
   651     proxyRecord = NULL;
 
   721     proxyRecord = NULL;
 
   652 
   722 
   653     if ( proxieRS->FindL(iSession) )
 
   723     if ( proxieRS->FindL(iSession) )
 
   654         {
 
   724         {
 
   655         TInt i( 0 );
 
   725         TInt i( 0 );
 
   656         while( i < proxieRS->iRecords.Count() )
 
   726         while ( i < proxieRS->iRecords.Count() )
 
   657             // Now that we have a list of services with the proper service type
 
   727             // Now that we have a list of services with the proper service type
 
   658             // search for our proxy record and remove it from the array,
 
   728             // search for our proxy record and remove it from the array,
 
   659             // then destroy the array.
 
   729             // then destroy the array.
 
   660             {
 
   730             {
 
   661             CCDProxiesRecord* proxyRecord = (*proxieRS)[i];
 
   731             CCDProxiesRecord* proxyRecord = (*proxieRS)[i];
 
   724 // ---------------------------------------------------------------------------
 
   794 // ---------------------------------------------------------------------------
 
   725 //
 
   795 //
 
   726 void CCmPluginBaseEng::LoadLocationRecordL()
 
   796 void CCmPluginBaseEng::LoadLocationRecordL()
 
   727     {
 
   797     {
 
   728     OstTraceFunctionEntry0( CCMPLUGINBASEENG_LOADLOCATIONSETTINGL_ENTRY );
 
   798     OstTraceFunctionEntry0( CCMPLUGINBASEENG_LOADLOCATIONSETTINGL_ENTRY );
 
   729 
       
   730     CCDLocationRecord* locationRecord = static_cast<CCDLocationRecord*>
 
       
   731                          (CCDRecordBase::RecordFactoryL(KCDTIdLocationRecord));
 
       
   732 
       
   733     CleanupStack::PushL( locationRecord );
 
       
   734 
       
   735     locationRecord->SetRecordId( iIapRecord->iLocation );
 
       
   736     if ( locationRecord->FindL(iSession) )
 
       
   737         {
 
       
   738         iLocationEnabled = ETrue;
 
       
   739 
       
   740         iLocationRecord = locationRecord;
 
       
   741 
       
   742         CleanupStack::Pop( locationRecord );
 
       
   743         }
 
       
   744     else
 
       
   745         {
 
       
   746         iLocationEnabled = EFalse;
 
       
   747 
       
   748         CleanupStack::PopAndDestroy( locationRecord );
 
       
   749         }
 
       
   750     OstTraceFunctionExit0( CCMPLUGINBASEENG_LOADLOCATIONSETTINGL_EXIT );
 
   799     OstTraceFunctionExit0( CCMPLUGINBASEENG_LOADLOCATIONSETTINGL_EXIT );
 
   751     }
 
   800     }
 
   752 
   801 
   753 // ---------------------------------------------------------------------------
 
   802 // ---------------------------------------------------------------------------
 
   754 // CCmPluginBaseEng::PrepareToUpdateRecordsL
 
   803 // CCmPluginBaseEng::PrepareToUpdateRecordsL
 
   755 // ---------------------------------------------------------------------------
 
   804 // ---------------------------------------------------------------------------
 
   756 //
 
   805 //
 
   757 void CCmPluginBaseEng::PrepareToUpdateRecordsL(
 
   806 void CCmPluginBaseEng::PrepareToUpdateRecordsL(
 
   758     CCmClientPluginInstance* aClientPluginInstance )
 
   807         CCmClientPluginInstance* aClientPluginInstance )
 
   759     {
 
   808     {
 
   760     OstTraceFunctionEntry0( CCMPLUGINBASEENG_PREPARETOUPDATERECORDSL_ENTRY );
 
   809     OstTraceFunctionEntry0( CCMPLUGINBASEENG_PREPARETOUPDATERECORDSL_ENTRY );
 
   761 
   810 
   762     // Set the record attributes to bearer specific records
 
   811     //TODO, Add null checks for mandatory generic record pointers.
 
   763     CCDIAPRecord* iapRecord =
 
   812     //
 
   764        static_cast<CCDIAPRecord*>( aClientPluginInstance->iGenRecordArray[KIapRecordIndex] );
 
   813 
       
   814     // Set the record attributes to bearer specific records.
 
       
   815     CCDIAPRecord* iapRecord = static_cast<CCDIAPRecord*>(
 
       
   816             aClientPluginInstance->iGenRecordArray[KIapRecordIndex] );
 
   765 
   817 
   766     for ( TInt i = 0; i < aClientPluginInstance->iBearerSpecRecordArray.Count(); i++ )
 
   818     for ( TInt i = 0; i < aClientPluginInstance->iBearerSpecRecordArray.Count(); i++ )
 
   767         {
 
   819         {
 
   768         CCDRecordBase* record =
 
   820         CCDRecordBase* record = static_cast<CCDRecordBase*>(
 
   769                 static_cast<CCDRecordBase*>( aClientPluginInstance->iBearerSpecRecordArray[i] );
 
   821                 aClientPluginInstance->iBearerSpecRecordArray[i] );
 
   770 
   822 
   771         CopyAttributes( iapRecord, record );
 
   823         CopyAttributes( iapRecord, record );
 
   772         }
 
   824         }
 
   773 
   825 
   774     PreparePluginToUpdateRecordsL( aClientPluginInstance->iGenRecordArray,
 
   826     PreparePluginToUpdateRecordsL(
 
   775                                    aClientPluginInstance->iBearerSpecRecordArray );
 
   827             aClientPluginInstance->iGenRecordArray,
 
       
   828             aClientPluginInstance->iBearerSpecRecordArray );
 
   776 
   829 
   777     OstTraceFunctionExit0( CCMPLUGINBASEENG_PREPARETOUPDATERECORDSL_EXIT );
 
   830     OstTraceFunctionExit0( CCMPLUGINBASEENG_PREPARETOUPDATERECORDSL_EXIT );
 
   778     }
 
   831     }
 
   779 
   832 
   780 // ---------------------------------------------------------------------------
 
   833 // ---------------------------------------------------------------------------
 
   781 // CCmPluginBaseEng::UpdateIAPRecordL
 
   834 // CCmPluginBaseEng::UpdateIAPRecordL
 
   782 // ---------------------------------------------------------------------------
 
   835 // ---------------------------------------------------------------------------
 
   783 //
 
   836 //
 
   784 void CCmPluginBaseEng::UpdateIAPRecordL(
 
   837 void CCmPluginBaseEng::UpdateIAPRecordL(
 
   785     CCmClientPluginInstance* aClientPluginInstance )
 
   838         CCmClientPluginInstance* aClientPluginInstance )
 
   786     {
 
   839     {
 
   787     OstTraceFunctionEntry0( CCMPLUGINBASEENG_UPDATEIAPRECORDL_ENTRY );
 
   840     OstTraceFunctionEntry0( CCMPLUGINBASEENG_UPDATEIAPRECORDL_ENTRY );
 
   788 
   841 
   789     CCDIAPRecord* iapRecord =
 
   842     CCDIAPRecord* iapRecord = static_cast<CCDIAPRecord*>(
 
   790        static_cast<CCDIAPRecord*>( aClientPluginInstance->iGenRecordArray[KIapRecordIndex] );
 
   843             aClientPluginInstance->iGenRecordArray[KIapRecordIndex] );
 
   791 
   844 
   792     if ( iIapId == 0 )
 
   845     if ( iIapId == 0 )
 
   793         {
 
   846         {
 
   794         // Otherwise predefined iapid
 
   847         // Otherwise predefined iapid.
 
   795         if ( !iIapRecord->RecordId() )
 
   848         if ( !iIapRecord->RecordId() )
 
   796             {
 
   849             {
 
   797             iIapRecord->SetRecordId( KCDNewRecordRequest );
 
   850             iIapRecord->SetRecordId( KCDNewRecordRequest );
 
   798             }
 
   851             }
 
   799 
   852 
   812         iIapRecord->iBearerType.SetL( *name );
 
   865         iIapRecord->iBearerType.SetL( *name );
 
   813         CleanupStack::PopAndDestroy( name );
 
   866         CleanupStack::PopAndDestroy( name );
 
   814 
   867 
   815         iIapRecord->iNetwork = iNetworkRecord->RecordId();
 
   868         iIapRecord->iNetwork = iNetworkRecord->RecordId();
 
   816 
   869 
   817         if ( iLocationRecord )
 
   870         iIapRecord->iLocation = GetLocationIdL();
 
   818             {
 
       
   819             iIapRecord->iLocation = iLocationRecord->RecordId();
 
       
   820             }
 
       
   821         else
 
       
   822             {
 
       
   823             iIapRecord->iLocation = GetLocationIdL();
 
       
   824             }
 
       
   825 
   871 
   826         CopyAttributes( iapRecord, iIapRecord );
 
   872         CopyAttributes( iapRecord, iIapRecord );
 
   827         CheckIfNameModifiedL( iapRecord, iIapRecord );
 
   873         CheckIfNameModifiedL( iapRecord, iIapRecord );
 
   828 
   874 
   829         iIapRecord->StoreL( iSession );
 
   875         iIapRecord->StoreL( iSession );
 
   838 
   884 
   839         aClientPluginInstance->iGenRecordArray.Remove( KIapRecordIndex );
 
   885         aClientPluginInstance->iGenRecordArray.Remove( KIapRecordIndex );
 
   840         CleanupStack::PushL( iapRecord );
 
   886         CleanupStack::PushL( iapRecord );
 
   841 
   887 
   842         aClientPluginInstance->iGenRecordArray.InsertL(
 
   888         aClientPluginInstance->iGenRecordArray.InsertL(
 
   843                 static_cast<CommsDat::CCDRecordBase*>( tempIapRecord ), KIapRecordIndex );
 
   889                 static_cast<CommsDat::CCDRecordBase*>( tempIapRecord ),
 
       
   890                 KIapRecordIndex );
 
   844 
   891 
   845         CleanupStack::PopAndDestroy( iapRecord );
 
   892         CleanupStack::PopAndDestroy( iapRecord );
 
   846         CleanupStack::Pop( tempIapRecord );
 
   893         CleanupStack::Pop( tempIapRecord );
 
   847 
       
   848         }
 
   894         }
 
   849     else
 
   895     else
 
   850         {
 
   896         {
 
   851         delete iIapRecord;
 
   897         delete iIapRecord;
 
   852         iIapRecord = NULL;
 
   898         iIapRecord = NULL;
 
   853 
   899 
   854         iIapRecord = static_cast<CCDIAPRecord*>
 
   900         iIapRecord = static_cast<CCDIAPRecord*>(
 
   855                             ( CCDRecordBase::CreateCopyRecordL( *iapRecord ) );
 
   901                 CCDRecordBase::CreateCopyRecordL( *iapRecord ) );
 
   856 
   902 
   857         iIapRecord->SetElementId( iapRecord->ElementId() );
 
   903         iIapRecord->SetElementId( iapRecord->ElementId() );
 
   858 
       
   859         iIapRecord->ModifyL( iSession );
 
   904         iIapRecord->ModifyL( iSession );
 
   860         }
 
   905         }
 
       
   906 
   861     OstTraceFunctionExit0( CCMPLUGINBASEENG_UPDATEIAPRECORDL_EXIT );
 
   907     OstTraceFunctionExit0( CCMPLUGINBASEENG_UPDATEIAPRECORDL_EXIT );
 
   862     }
 
   908     }
 
   863 
   909 
   864 // ---------------------------------------------------------------------------
 
   910 // ---------------------------------------------------------------------------
 
   865 // CCmPluginBaseEng::UpdateProxyRecordL
 
   911 // CCmPluginBaseEng::UpdateProxyRecordL
 
   874             aClientPluginInstance->iGenRecordArray[KIapRecordIndex] );
 
   920             aClientPluginInstance->iGenRecordArray[KIapRecordIndex] );
 
   875 
   921 
   876     CCDProxiesRecord* proxyRecord = static_cast<CCDProxiesRecord*>(
 
   922     CCDProxiesRecord* proxyRecord = static_cast<CCDProxiesRecord*>(
 
   877             aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] );
 
   923             aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] );
 
   878 
   924 
       
   925     if ( !iapRecord || !proxyRecord )
 
       
   926         {
 
       
   927         User::Leave( KErrCorrupt );
 
       
   928         }
 
       
   929 
   879     CopyAttributes( iapRecord, proxyRecord );
 
   930     CopyAttributes( iapRecord, proxyRecord );
 
   880     CheckIfNameModifiedL( iapRecord, proxyRecord );
 
   931     CheckIfNameModifiedL( iapRecord, proxyRecord );
 
   881 
   932 
   882     if ( proxyRecord->iUseProxyServer )
 
   933     if ( proxyRecord->iUseProxyServer )
 
   883         {
 
   934         {
 
   884         delete iProxyRecord;
 
   935         delete iProxyRecord;
 
   885         iProxyRecord = NULL;
 
   936         iProxyRecord = NULL;
 
   886 
   937 
   887         iProxyRecord = static_cast<CCDProxiesRecord*>
 
   938         iProxyRecord = static_cast<CCDProxiesRecord*>(
 
   888                             ( CCDRecordBase::CreateCopyRecordL( *proxyRecord ) );
 
   939                 CCDRecordBase::CreateCopyRecordL( *proxyRecord ) );
 
   889         iProxyRecord->SetElementId( proxyRecord->ElementId() );
 
   940         iProxyRecord->SetElementId( proxyRecord->ElementId() );
 
   890 
   941 
   891         if ( !iProxyRecord->RecordId() )
 
   942         if ( !iProxyRecord->RecordId() )
 
   892             // new proxy setting -> create new record
 
   943             {
 
   893             {
 
   944             // New proxy setting -> create new record.
 
   894             iProxyRecord->iService = iServiceRecord->RecordId();
 
   945             iProxyRecord->iService = iServiceRecord->RecordId();
 
   895             iProxyRecord->iServiceType.SetL( iIapRecord->iServiceType );
 
   946             iProxyRecord->iServiceType.SetL( iIapRecord->iServiceType );
 
   896 
   947 
   897             // By default protocol is set to "http"
 
   948             // By default protocol is set to "http".
 
   898             if ( TPtrC( proxyRecord->iProtocolName ).Length() == 0 )
 
   949             if ( TPtrC( proxyRecord->iProtocolName ).Length() == 0 )
 
   899                 {
 
   950                 {
 
   900                 iProxyRecord->iProtocolName.SetL( KDefProxyProtocolName );
 
   951                 iProxyRecord->iProtocolName.SetL( KDefProxyProtocolName );
 
   901                 }
 
   952                 }
 
   902 
   953 
   905             proxyRecord->SetElementId( iProxyRecord->ElementId() );
 
   956             proxyRecord->SetElementId( iProxyRecord->ElementId() );
 
   906             proxyRecord->iService = iServiceRecord->RecordId();
 
   957             proxyRecord->iService = iServiceRecord->RecordId();
 
   907             proxyRecord->iServiceType.SetL( iIapRecord->iServiceType );
 
   958             proxyRecord->iServiceType.SetL( iIapRecord->iServiceType );
 
   908             }
 
   959             }
 
   909         else
 
   960         else
 
   910             // already existing record -> update only
 
   961             // Already existing record -> update only.
 
   911             {
 
   962             {
 
   912             iProxyRecord->ModifyL( iSession );
 
   963             iProxyRecord->ModifyL( iSession );
 
   913             }
 
   964             }
 
   914         }
 
   965         }
 
   915     else
 
   966     else
 
   917         if ( iProxyRecord->RecordId() )
 
   968         if ( iProxyRecord->RecordId() )
 
   918             {
 
   969             {
 
   919             iProxyRecord->DeleteL( iSession );
 
   970             iProxyRecord->DeleteL( iSession );
 
   920             }
 
   971             }
 
   921         }
 
   972         }
 
       
   973 
   922     OstTraceFunctionExit0( CCMPLUGINBASEENG_UPDATEPROXYRECORDL_EXIT );
 
   974     OstTraceFunctionExit0( CCMPLUGINBASEENG_UPDATEPROXYRECORDL_EXIT );
 
   923     }
 
   975     }
 
   924 
   976 
   925 // ---------------------------------------------------------------------------
 
   977 // ---------------------------------------------------------------------------
 
   926 // CCmPluginBaseEng::UpdateMetadataRecordL
 
   978 // CCmPluginBaseEng::UpdateMetadataRecordL
 
   929 void CCmPluginBaseEng::UpdateMetadataRecordL(
 
   981 void CCmPluginBaseEng::UpdateMetadataRecordL(
 
   930         CCmClientPluginInstance* aClientPluginInstance )
 
   982         CCmClientPluginInstance* aClientPluginInstance )
 
   931     {
 
   983     {
 
   932     OstTraceFunctionEntry0( CCMPLUGINBASEENG_UPDATEMETADATARECORDL_ENTRY );
 
   984     OstTraceFunctionEntry0( CCMPLUGINBASEENG_UPDATEMETADATARECORDL_ENTRY );
 
   933 
   985 
   934     CCDIAPRecord* iapRecord = static_cast<CCDIAPRecord*>(
 
   986     CCDIAPRecord* clientIapRecord = static_cast<CCDIAPRecord*>(
 
   935             aClientPluginInstance->iGenRecordArray[KIapRecordIndex] );
 
   987             aClientPluginInstance->iGenRecordArray[KIapRecordIndex] );
 
   936 
   988 
   937     CCDIAPMetadataRecord* metadataRecord = static_cast<CCDIAPMetadataRecord*>(
 
   989     CCDIAPMetadataRecord* clientMetadataRecord = static_cast<CCDIAPMetadataRecord*>(
 
   938             aClientPluginInstance->iGenRecordArray[KMetaDataRecordIndex] );
 
   990             aClientPluginInstance->iGenRecordArray[KMetaDataRecordIndex] );
 
   939 
   991 
   940     CopyAttributes( iapRecord, metadataRecord );
 
   992     // Adjust client side metadata record attributes and name if needed.
 
   941     CheckIfNameModifiedL( iapRecord, metadataRecord );
 
   993     CopyAttributes( clientIapRecord, clientMetadataRecord );
 
   942 
   994     CheckIfNameModifiedL( clientIapRecord, clientMetadataRecord );
 
       
   995 
       
   996     // Make a copy of client's metadata record and save to database.
 
   943     delete iMetaDataRecord;
 
   997     delete iMetaDataRecord;
 
   944     iMetaDataRecord = NULL;
 
   998     iMetaDataRecord = NULL;
 
   945 
   999     iMetaDataRecord = new( ELeave ) CCDIAPMetadataRecord( iMetadataTableId );
 
   946     // Get a new blank IAP metadata record.
 
  1000     CopyRecordFieldsL( *clientMetadataRecord, *iMetaDataRecord );
 
   947     iMetaDataRecord = NewMetadataRecordL( EFalse );
 
  1001     iMetaDataRecord->SetElementId( clientMetadataRecord->ElementId() );
 
   948 
       
   949     iMetaDataRecord->SetElementId( metadataRecord->ElementId() );
 
       
   950     iMetaDataRecord->iRecordName.SetL( metadataRecord->iRecordName );
 
       
   951     iMetaDataRecord->iMetadata.SetL( metadataRecord->iMetadata );
 
       
   952     iMetaDataRecord->iSeamlessness.SetL( metadataRecord->iSeamlessness );
 
       
   953 
  1002 
   954     if ( !iMetaDataRecord->RecordId() )
 
  1003     if ( !iMetaDataRecord->RecordId() )
 
   955         {
 
  1004         {
 
   956         iMetaDataRecord->iIAP = IAPRecordElementId();
 
  1005         iMetaDataRecord->iIAP = IAPRecordElementId();
 
   957         iMetaDataRecord->SetRecordId( KCDNewRecordRequest );
 
  1006         iMetaDataRecord->SetRecordId( KCDNewRecordRequest );
 
   958         iMetaDataRecord->StoreL( iSession );
 
  1007         iMetaDataRecord->StoreL( iSession );
 
   959         metadataRecord->SetElementId( iMetaDataRecord->ElementId() );
 
  1008         clientMetadataRecord->SetElementId( iMetaDataRecord->ElementId() );
 
   960         }
 
  1009         }
 
   961     else
 
  1010     else
 
   962         {
 
  1011         {
 
   963         iMetaDataRecord->ModifyL( iSession );
 
  1012         iMetaDataRecord->ModifyL( iSession );
 
   964         }
 
  1013         }
 
   973 void CCmPluginBaseEng::UpdateServiceRecordL(
 
  1022 void CCmPluginBaseEng::UpdateServiceRecordL(
 
   974     CCmClientPluginInstance* aClientPluginInstance )
 
  1023     CCmClientPluginInstance* aClientPluginInstance )
 
   975     {
 
  1024     {
 
   976     OstTraceFunctionEntry0( CCMPLUGINBASEENG_UPDATESERVICERECORDL_ENTRY );
 
  1025     OstTraceFunctionEntry0( CCMPLUGINBASEENG_UPDATESERVICERECORDL_ENTRY );
 
   977 
  1026 
   978     CCDIAPRecord* iapRecord =
 
  1027     CCDIAPRecord* iapRecord = static_cast<CCDIAPRecord*>(
 
   979                 static_cast<CCDIAPRecord*>( aClientPluginInstance->iGenRecordArray[KIapRecordIndex] );
 
  1028             aClientPluginInstance->iGenRecordArray[KIapRecordIndex] );
 
   980 
  1029 
   981     CCDRecordBase* serviceRecord =
 
  1030     CCDRecordBase* serviceRecord = static_cast<CCDRecordBase*>(
 
   982                 static_cast<CCDRecordBase*>( aClientPluginInstance->iGenRecordArray[KServiceRecordIndex] );
 
  1031             aClientPluginInstance->iGenRecordArray[KServiceRecordIndex] );
 
   983 
  1032 
   984     CopyAttributes( iapRecord, serviceRecord );
 
  1033     CopyAttributes( iapRecord, serviceRecord );
 
   985 
  1034 
   986     UpdateServiceRecordL( aClientPluginInstance->iGenRecordArray,
 
  1035     UpdateServiceRecordL(
 
   987                           aClientPluginInstance->iBearerSpecRecordArray );
 
  1036             aClientPluginInstance->iGenRecordArray,
 
       
  1037             aClientPluginInstance->iBearerSpecRecordArray );
 
   988 
  1038 
   989     OstTraceFunctionExit0( CCMPLUGINBASEENG_UPDATESERVICERECORDL_EXIT );
 
  1039     OstTraceFunctionExit0( CCMPLUGINBASEENG_UPDATESERVICERECORDL_EXIT );
 
   990     }
 
  1040     }
 
   991 
  1041 
   992 // ---------------------------------------------------------------------------
 
  1042 // ---------------------------------------------------------------------------
 
   993 // CCmPluginBaseEng::UpdateNetworkRecordL
 
  1043 // CCmPluginBaseEng::UpdateNetworkRecordL
 
   994 // ---------------------------------------------------------------------------
 
  1044 // ---------------------------------------------------------------------------
 
   995 //
 
  1045 //
 
   996 void CCmPluginBaseEng::UpdateNetworkRecordL(
 
  1046 void CCmPluginBaseEng::UpdateNetworkRecordL(
 
   997     CCmClientPluginInstance* aClientPluginInstance )
 
  1047         CCmClientPluginInstance* aClientPluginInstance )
 
   998     {
 
  1048     {
 
   999     OstTraceFunctionEntry0( CCMPLUGINBASEENG_UPDATENETWORKRECORDL_ENTRY );
 
  1049     OstTraceFunctionEntry0( CCMPLUGINBASEENG_UPDATENETWORKRECORDL_ENTRY );
 
  1000 
  1050 
  1001     CCDIAPRecord* iapRecord =
 
  1051     CCDIAPRecord* iapRecord = static_cast<CCDIAPRecord*>(
 
  1002                 static_cast<CCDIAPRecord*>( aClientPluginInstance->iGenRecordArray[KIapRecordIndex] );
 
  1052             aClientPluginInstance->iGenRecordArray[KIapRecordIndex] );
 
  1003 
  1053 
  1004     CCDNetworkRecord* networkRecord =
 
  1054     CCDNetworkRecord* networkRecord = static_cast<CCDNetworkRecord*>(
 
  1005                 static_cast<CCDNetworkRecord*>( aClientPluginInstance->iGenRecordArray[KNetworkRecordIndex] );
 
  1055             aClientPluginInstance->iGenRecordArray[KNetworkRecordIndex] );
 
  1006 
  1056 
  1007     CopyAttributes( iapRecord, networkRecord );
 
  1057     CopyAttributes( iapRecord, networkRecord );
 
  1008 
  1058 
  1009     delete iNetworkRecord;
 
  1059     delete iNetworkRecord;
 
  1010     iNetworkRecord = NULL;
 
  1060     iNetworkRecord = NULL;
 
  1011 
  1061 
  1012     CheckIfNameModifiedL( iapRecord, networkRecord );
 
  1062     CheckIfNameModifiedL( iapRecord, networkRecord );
 
  1013 
  1063 
  1014     iNetworkRecord = static_cast<CCDNetworkRecord*>
 
  1064     iNetworkRecord = static_cast<CCDNetworkRecord*>(
 
  1015                         ( CCDRecordBase::CreateCopyRecordL( *networkRecord ) );
 
  1065             CCDRecordBase::CreateCopyRecordL( *networkRecord ) );
 
  1016 
  1066 
  1017     iNetworkRecord->SetElementId( networkRecord->ElementId() );
 
  1067     iNetworkRecord->SetElementId( networkRecord->ElementId() );
 
  1018 
  1068 
  1019     if ( !iNetworkRecord->RecordId() )
 
  1069     if ( !iNetworkRecord->RecordId() )
 
  1020         {
 
  1070         {
 
  1024         }
 
  1074         }
 
  1025     else
 
  1075     else
 
  1026         {
 
  1076         {
 
  1027         iNetworkRecord->ModifyL( iSession );
 
  1077         iNetworkRecord->ModifyL( iSession );
 
  1028         }
 
  1078         }
 
       
  1079 
  1029     OstTraceFunctionExit0( CCMPLUGINBASEENG_UPDATENETWORKRECORDL_EXIT );
 
  1080     OstTraceFunctionExit0( CCMPLUGINBASEENG_UPDATENETWORKRECORDL_EXIT );
 
  1030     }
 
  1081     }
 
  1031 
  1082 
  1032 // ---------------------------------------------------------------------------
 
  1083 // ---------------------------------------------------------------------------
 
  1033 // CCmPluginBaseEng::UpdateLocationRecordL
 
  1084 // CCmPluginBaseEng::UpdateLocationRecordL
 
  1034 // ---------------------------------------------------------------------------
 
  1085 // ---------------------------------------------------------------------------
 
  1035 //
 
  1086 //
 
  1036 void CCmPluginBaseEng::UpdateLocationRecordL(
 
  1087 void CCmPluginBaseEng::UpdateLocationRecordL(
 
  1037     CCmClientPluginInstance* aClientPluginInstance )
 
  1088         CCmClientPluginInstance* /*aClientPluginInstance*/ )
 
  1038     {
 
  1089     {
 
  1039     OstTraceFunctionEntry0( CCMPLUGINBASEENG_UPDATELOCATIONRECORDL_ENTRY );
 
  1090     OstTraceFunctionEntry0( CCMPLUGINBASEENG_UPDATELOCATIONRECORDL_ENTRY );
 
  1040 
       
  1041     if ( iLocationEnabled )
 
       
  1042         {
 
       
  1043         CCDIAPRecord* iapRecord =
 
       
  1044                     static_cast<CCDIAPRecord*>( aClientPluginInstance->iGenRecordArray[KIapRecordIndex] );
 
       
  1045 
       
  1046         CCDLocationRecord* locationRecord =
 
       
  1047                     static_cast<CCDLocationRecord*>( aClientPluginInstance->iGenRecordArray[KLocationRecordIndex] );
 
       
  1048 
       
  1049         // location record is not set as hidden because it can be shared between iaps
 
       
  1050         CopyAttributes( iapRecord, locationRecord );
 
       
  1051         locationRecord->ClearAttributes( ECDHidden );
 
       
  1052 
       
  1053         delete iLocationRecord;
 
       
  1054         iLocationRecord = NULL;
 
       
  1055 
       
  1056         iLocationRecord = static_cast<CCDLocationRecord*>
 
       
  1057                             ( CCDRecordBase::CreateCopyRecordL( *locationRecord ) );
 
       
  1058 
       
  1059         iLocationRecord->SetElementId( locationRecord->ElementId() );
 
       
  1060 
       
  1061         CheckIfNameModifiedL( iapRecord, locationRecord );
 
       
  1062 
       
  1063         if ( !iLocationRecord->RecordId() )
 
       
  1064             {
 
       
  1065             iLocationRecord->SetRecordId( KCDNewRecordRequest );
 
       
  1066             iLocationRecord->StoreL( iSession );
 
       
  1067             }
 
       
  1068         else
 
       
  1069             {
 
       
  1070             iLocationRecord->ModifyL( iSession );
 
       
  1071             }
 
       
  1072         }
 
       
  1073     else
 
       
  1074         {
 
       
  1075         if ( iLocationRecord )
 
       
  1076             {
 
       
  1077             iLocationRecord->DeleteL( iSession );
 
       
  1078             }
 
       
  1079         }
 
       
  1080     OstTraceFunctionExit0( CCMPLUGINBASEENG_UPDATELOCATIONRECORDL_EXIT );
 
  1091     OstTraceFunctionExit0( CCMPLUGINBASEENG_UPDATELOCATIONRECORDL_EXIT );
 
  1081     }
 
  1092     }
 
  1082 
  1093 
  1083 // ---------------------------------------------------------------------------
 
  1094 // ---------------------------------------------------------------------------
 
  1084 // CCmPluginBaseEng::UpdateConnPrefSettingL
 
  1095 // CCmPluginBaseEng::UpdateConnPrefSettingL
 
  1103         User::Leave( KErrNotSupported );
 
  1114         User::Leave( KErrNotSupported );
 
  1104         }
 
  1115         }
 
  1105 
  1116 
  1106     if ( !iProxyRecord )
 
  1117     if ( !iProxyRecord )
 
  1107         {
 
  1118         {
 
  1108         iProxyRecord = static_cast<CCDProxiesRecord *>
 
  1119         iProxyRecord = static_cast<CCDProxiesRecord *>(
 
  1109                       (CCDRecordBase::RecordFactoryL(KCDTIdProxiesRecord));
 
  1120                 CCDRecordBase::RecordFactoryL( KCDTIdProxiesRecord ) );
 
  1110         }
 
  1121         }
 
  1111 
  1122 
  1112     iProxyRecord->iUseProxyServer = aEnable;
 
  1123     iProxyRecord->iUseProxyServer = aEnable;
 
  1113 
  1124 
  1114     OstTraceFunctionExit0( CCMPLUGINBASEENG_ENABLEPROXYL_EXIT );
 
  1125     OstTraceFunctionExit0( CCMPLUGINBASEENG_ENABLEPROXYL_EXIT );
 
  1120 //
 
  1131 //
 
  1121 void CCmPluginBaseEng::EnableLocationL( TBool aEnable )
 
  1132 void CCmPluginBaseEng::EnableLocationL( TBool aEnable )
 
  1122     {
 
  1133     {
 
  1123     OstTraceFunctionEntry0( CCMPLUGINBASEENG_ENABLELOCATIONL_ENTRY );
 
  1134     OstTraceFunctionEntry0( CCMPLUGINBASEENG_ENABLELOCATIONL_ENTRY );
 
  1124 
  1135 
  1125     if ( aEnable )
 
  1136     // Not supported anymore
 
  1126         {
 
       
  1127         if ( !iLocationRecord )
 
       
  1128             {
 
       
  1129             iLocationRecord = static_cast<CCDLocationRecord *>
 
       
  1130                          (CCDRecordBase::RecordFactoryL(KCDTIdLocationRecord));
 
       
  1131             }
 
       
  1132         }
 
       
  1133 
       
  1134     iLocationEnabled = aEnable;
 
  1137     iLocationEnabled = aEnable;
 
  1135 
  1138 
  1136     OstTraceFunctionExit0( CCMPLUGINBASEENG_ENABLELOCATIONL_EXIT );
 
  1139     OstTraceFunctionExit0( CCMPLUGINBASEENG_ENABLELOCATIONL_EXIT );
 
  1137     }
 
  1140     }
 
  1138 
  1141 
  1145     OstTraceFunctionEntry0( CCMPLUGINBASEENG_LOADWAPRECORDL_ENTRY );
 
  1148     OstTraceFunctionEntry0( CCMPLUGINBASEENG_LOADWAPRECORDL_ENTRY );
 
  1146 
  1149 
  1147     iWapIPBearerRecord = FindWAPRecordL();
 
  1150     iWapIPBearerRecord = FindWAPRecordL();
 
  1148     if ( iWapIPBearerRecord )
 
  1151     if ( iWapIPBearerRecord )
 
  1149         {
 
  1152         {
 
  1150         CCDWAPAccessPointRecord *wapApRecord = static_cast<CCDWAPAccessPointRecord *>
 
  1153         CCDWAPAccessPointRecord *wapApRecord = static_cast<CCDWAPAccessPointRecord*>(
 
  1151                    (CCDRecordBase::RecordFactoryL(KCDTIdWAPAccessPointRecord));
 
  1154                 CCDRecordBase::RecordFactoryL( KCDTIdWAPAccessPointRecord ) );
 
  1152 
  1155 
  1153         CleanupStack::PushL( wapApRecord );
 
  1156         CleanupStack::PushL( wapApRecord );
 
  1154 
  1157 
  1155         wapApRecord->SetRecordId( iWapIPBearerRecord->iWAPAccessPointId );
 
  1158         wapApRecord->SetRecordId( iWapIPBearerRecord->iWAPAccessPointId );
 
  1156         TRAPD( err, wapApRecord->LoadL( iSession ) );
 
  1159         TRAPD( err, wapApRecord->LoadL( iSession ) );
 
  1157         if ( err == KErrNotFound )
 
  1160         if ( err == KErrNotFound )
 
  1158             {
 
  1161             {
 
  1159             CleanupStack::PopAndDestroy( wapApRecord );
 
  1162             CleanupStack::PopAndDestroy( wapApRecord );
 
  1160 
  1163 
  1161             wapApRecord = static_cast<CCDWAPAccessPointRecord *>
 
  1164             wapApRecord = static_cast<CCDWAPAccessPointRecord*>(
 
  1162                    (CCDRecordBase::RecordFactoryL(KCDTIdWAPAccessPointRecord));
 
  1165                     CCDRecordBase::RecordFactoryL( KCDTIdWAPAccessPointRecord ) );
 
  1163             }
 
  1166             }
 
  1164         else
 
  1167         else
 
  1165             {
 
  1168             {
 
  1166             User::LeaveIfError( err );
 
  1169             User::LeaveIfError( err );
 
  1167 
  1170 
  1173     else
 
  1176     else
 
  1174         // No WAP record found -> create a new one
 
  1177         // No WAP record found -> create a new one
 
  1175         {
 
  1178         {
 
  1176         NewWapRecordL();
 
  1179         NewWapRecordL();
 
  1177         }
 
  1180         }
 
       
  1181 
  1178     OstTraceFunctionExit0( CCMPLUGINBASEENG_LOADWAPRECORDL_EXIT );
 
  1182     OstTraceFunctionExit0( CCMPLUGINBASEENG_LOADWAPRECORDL_EXIT );
 
  1179     }
 
  1183     }
 
  1180 
  1184 
  1181 // ---------------------------------------------------------------------------
 
  1185 // ---------------------------------------------------------------------------
 
  1182 // CCmPluginBaseEng::LoadMetadataRecordL
 
  1186 // CCmPluginBaseEng::LoadMetadataRecordL
 
  1194 // ---------------------------------------------------------------------------
 
  1198 // ---------------------------------------------------------------------------
 
  1195 // CCmPluginBaseEng::UpdateWapRecordL
 
  1199 // CCmPluginBaseEng::UpdateWapRecordL
 
  1196 // ---------------------------------------------------------------------------
 
  1200 // ---------------------------------------------------------------------------
 
  1197 //
 
  1201 //
 
  1198 void CCmPluginBaseEng::UpdateWapRecordL(
 
  1202 void CCmPluginBaseEng::UpdateWapRecordL(
 
  1199     CCmClientPluginInstance* aClientPluginInstance )
 
  1203         CCmClientPluginInstance* aClientPluginInstance )
 
  1200     {
 
  1204     {
 
  1201     OstTraceFunctionEntry0( CCMPLUGINBASEENG_UPDATEWAPRECORDL_ENTRY );
 
  1205     OstTraceFunctionEntry0( CCMPLUGINBASEENG_UPDATEWAPRECORDL_ENTRY );
 
  1202 
  1206 
  1203     delete iWapAPRecord;
 
  1207     delete iWapAPRecord;
 
  1204     iWapAPRecord = NULL;
 
  1208     iWapAPRecord = NULL;
 
  1205 
  1209 
  1206     delete iWapIPBearerRecord;
 
  1210     delete iWapIPBearerRecord;
 
  1207     iWapIPBearerRecord = NULL;
 
  1211     iWapIPBearerRecord = NULL;
 
  1208 
  1212 
  1209     CCDIAPRecord* iapRecord =
 
  1213     CCDIAPRecord* iapRecord = static_cast<CCDIAPRecord*>(
 
  1210         static_cast<CCDIAPRecord*>( aClientPluginInstance->iGenRecordArray[KIapRecordIndex] );
 
  1214             aClientPluginInstance->iGenRecordArray[KIapRecordIndex] );
 
  1211 
  1215 
  1212     CCDWAPAccessPointRecord* wapAPRecord =
 
  1216     CCDWAPAccessPointRecord* wapAPRecord = static_cast<CCDWAPAccessPointRecord*>(
 
  1213         static_cast<CCDWAPAccessPointRecord*>( aClientPluginInstance->iGenRecordArray[KWAPAPRecordIndex] );
 
  1217             aClientPluginInstance->iGenRecordArray[KWAPAPRecordIndex] );
 
  1214 
  1218 
  1215     CCDWAPIPBearerRecord* wapIPBearerRecord =
 
  1219     CCDWAPIPBearerRecord* wapIPBearerRecord = static_cast<CCDWAPIPBearerRecord*>(
 
  1216         static_cast<CCDWAPIPBearerRecord*>( aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] );
 
  1220             aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] );
 
  1217 
  1221 
  1218     CopyAttributes( iapRecord, wapAPRecord );
 
  1222     CopyAttributes( iapRecord, wapAPRecord );
 
  1219     CopyAttributes( iapRecord, wapIPBearerRecord );
 
  1223     CopyAttributes( iapRecord, wapIPBearerRecord );
 
  1220 
  1224 
  1221     CheckIfNameModifiedL( iapRecord, wapAPRecord );
 
  1225     CheckIfNameModifiedL( iapRecord, wapAPRecord );
 
  1222     CheckIfNameModifiedL( iapRecord, wapIPBearerRecord );
 
  1226     CheckIfNameModifiedL( iapRecord, wapIPBearerRecord );
 
  1223 
  1227 
  1224     iWapAPRecord = static_cast<CCDWAPAccessPointRecord*>
 
  1228     iWapAPRecord = static_cast<CCDWAPAccessPointRecord*>(
 
  1225                             ( CCDRecordBase::CreateCopyRecordL( *wapAPRecord ) );
 
  1229             CCDRecordBase::CreateCopyRecordL( *wapAPRecord ) );
 
  1226     iWapAPRecord->SetElementId( wapAPRecord->ElementId() );
 
  1230     iWapAPRecord->SetElementId( wapAPRecord->ElementId() );
 
  1227 
  1231 
  1228     iWapIPBearerRecord = static_cast<CCDWAPIPBearerRecord*>
 
  1232     iWapIPBearerRecord = static_cast<CCDWAPIPBearerRecord*>(
 
  1229                         ( CCDRecordBase::CreateCopyRecordL( *wapIPBearerRecord ) );
 
  1233             CCDRecordBase::CreateCopyRecordL( *wapIPBearerRecord ) );
 
  1230     iWapIPBearerRecord->SetElementId( wapIPBearerRecord->ElementId() );
 
  1234     iWapIPBearerRecord->SetElementId( wapIPBearerRecord->ElementId() );
 
  1231 
  1235 
  1232     if ( !iWapAPRecord->RecordId() )
 
  1236     if ( !iWapAPRecord->RecordId() )
 
  1233         {
 
  1237         {
 
  1234         iWapAPRecord->SetRecordId( KCDNewRecordRequest );
 
  1238         iWapAPRecord->SetRecordId( KCDNewRecordRequest );
 
  1254         }
 
  1258         }
 
  1255     else
 
  1259     else
 
  1256         {
 
  1260         {
 
  1257         iWapIPBearerRecord->ModifyL( iSession );
 
  1261         iWapIPBearerRecord->ModifyL( iSession );
 
  1258         }
 
  1262         }
 
       
  1263 
  1259     OstTraceFunctionExit0( DUP1_CCMPLUGINBASEENG_UPDATEWAPRECORDL_EXIT );
 
  1264     OstTraceFunctionExit0( DUP1_CCMPLUGINBASEENG_UPDATEWAPRECORDL_EXIT );
 
  1260     }
 
  1265     }
 
  1261 
  1266 
  1262 // ---------------------------------------------------------------------------
 
  1267 // ---------------------------------------------------------------------------
 
  1263 // CCmPluginBaseEng::NewWapRecordL
 
  1268 // CCmPluginBaseEng::NewWapRecordL
 
  1267     {
 
  1272     {
 
  1268     OstTraceFunctionEntry0( CCMPLUGINBASEENG_NEWWAPRECORDL_ENTRY );
 
  1273     OstTraceFunctionEntry0( CCMPLUGINBASEENG_NEWWAPRECORDL_ENTRY );
 
  1269 
  1274 
  1270     if ( !iWapIPBearerRecord )
 
  1275     if ( !iWapIPBearerRecord )
 
  1271         {
 
  1276         {
 
  1272         iWapIPBearerRecord = static_cast<CCDWAPIPBearerRecord *>
 
  1277         iWapIPBearerRecord = static_cast<CCDWAPIPBearerRecord*>(
 
  1273                       ( CCDRecordBase::RecordFactoryL( KCDTIdWAPIPBearerRecord ) );
 
  1278                 CCDRecordBase::RecordFactoryL( KCDTIdWAPIPBearerRecord ) );
 
  1274         iWapIPBearerRecord->iWAPProxyPort = 0;
 
  1279         iWapIPBearerRecord->iWAPProxyPort = 0;
 
  1275         iWapIPBearerRecord->iWAPWSPOption = ECmWapWspOptionConnectionOriented;
 
  1280         iWapIPBearerRecord->iWAPWSPOption = ECmWapWspOptionConnectionOriented;
 
  1276         iWapIPBearerRecord->iWAPSecurity = EFalse;
 
  1281         iWapIPBearerRecord->iWAPSecurity = EFalse;
 
  1277         }
 
  1282         }
 
  1278 
  1283 
  1279     if ( !iWapAPRecord )
 
  1284     if ( !iWapAPRecord )
 
  1280         {
 
  1285         {
 
  1281         iWapAPRecord = static_cast<CCDWAPAccessPointRecord *>
 
  1286         iWapAPRecord = static_cast<CCDWAPAccessPointRecord*>(
 
  1282                    ( CCDRecordBase::RecordFactoryL( KCDTIdWAPAccessPointRecord ) );
 
  1287                 CCDRecordBase::RecordFactoryL( KCDTIdWAPAccessPointRecord ) );
 
  1283         // SMS bearer is not supported by this version
 
  1288         // SMS bearer is not supported by this version.
 
  1284         iWapAPRecord->iWAPCurrentBearer.SetL( TPtrC( KCDTypeNameWAPIPBearer ) );
 
  1289         iWapAPRecord->iWAPCurrentBearer.SetL( TPtrC( KCDTypeNameWAPIPBearer ) );
 
  1285         }
 
  1290         }
 
       
  1291 
  1286     OstTraceFunctionExit0( CCMPLUGINBASEENG_NEWWAPRECORDL_EXIT );
 
  1292     OstTraceFunctionExit0( CCMPLUGINBASEENG_NEWWAPRECORDL_EXIT );
 
  1287     }
 
  1293     }
 
  1288 
  1294 
  1289 // ---------------------------------------------------------------------------
 
  1295 // ---------------------------------------------------------------------------
 
  1290 // CCmPluginBaseEng::NewMetadataRecordL
 
  1296 // CCmPluginBaseEng::NewMetadataRecordL
 
  1311 
  1317 
  1312 // ---------------------------------------------------------------------------
 
  1318 // ---------------------------------------------------------------------------
 
  1313 // CCmPluginBaseEng::SetAttribute
 
  1319 // CCmPluginBaseEng::SetAttribute
 
  1314 // ---------------------------------------------------------------------------
 
  1320 // ---------------------------------------------------------------------------
 
  1315 //
 
  1321 //
 
  1316 void CCmPluginBaseEng::SetAttribute( CCDRecordBase* aRecord,
 
  1322 void CCmPluginBaseEng::SetAttribute(
 
  1317                                      TUint32 aAttribute,
 
  1323         CCDRecordBase* aRecord,
 
  1318                                      TBool aSet )
 
  1324         TUint32 aAttribute,
 
       
  1325         TBool aSet )
 
  1319     {
 
  1326     {
 
  1320     OstTraceFunctionEntry0( CCMPLUGINBASEENG_SETATTRIBUTE_ENTRY );
 
  1327     OstTraceFunctionEntry0( CCMPLUGINBASEENG_SETATTRIBUTE_ENTRY );
 
  1321 
  1328 
  1322     if ( aSet )
 
  1329     if ( aSet )
 
  1323         {
 
  1330         {
 
  1333 
  1340 
  1334 // ---------------------------------------------------------------------------
 
  1341 // ---------------------------------------------------------------------------
 
  1335 // CCmPluginBaseEng::CopyAttributes
 
  1342 // CCmPluginBaseEng::CopyAttributes
 
  1336 // ---------------------------------------------------------------------------
 
  1343 // ---------------------------------------------------------------------------
 
  1337 //
 
  1344 //
 
  1338 void CCmPluginBaseEng::CopyAttributes( CCDRecordBase* aSrcRecord,
 
  1345 void CCmPluginBaseEng::CopyAttributes(
 
  1339                                        CCDRecordBase* aDstRecord )
 
  1346         CCDRecordBase* aSrcRecord,
 
       
  1347         CCDRecordBase* aDstRecord )
 
  1340     {
 
  1348     {
 
  1341     OstTraceFunctionEntry0( CCMPLUGINBASEENG_COPYATTRIBUTES_ENTRY );
 
  1349     OstTraceFunctionEntry0( CCMPLUGINBASEENG_COPYATTRIBUTES_ENTRY );
 
  1342 
  1350 
  1343     if ( aSrcRecord == NULL || aDstRecord == NULL )
 
  1351     if ( aSrcRecord == NULL || aDstRecord == NULL )
 
  1344         {
 
  1352         {
 
       
  1353         OstTraceFunctionExit0( CCMPLUGINBASEENG_COPYATTRIBUTES_EXIT );
 
  1345         return;
 
  1354         return;
 
  1346         }
 
  1355         }
 
  1347 
  1356 
  1348     // clear the target record attributes first
 
  1357     // Clear the target record attributes first.
 
  1349     aDstRecord->ClearAttributes( aDstRecord->Attributes() );
 
  1358     aDstRecord->ClearAttributes( aDstRecord->Attributes() );
 
  1350 
       
  1351     aDstRecord->SetAttributes( aSrcRecord->Attributes() );
 
  1359     aDstRecord->SetAttributes( aSrcRecord->Attributes() );
 
  1352 
  1360 
  1353     OstTraceFunctionExit0( CCMPLUGINBASEENG_COPYATTRIBUTES_EXIT );
 
  1361     OstTraceFunctionExit0( DUP1_CCMPLUGINBASEENG_COPYATTRIBUTES_EXIT );
 
  1354     }
 
  1362     }
 
  1355 
  1363 
  1356 // ---------------------------------------------------------------------------
 
  1364 // ---------------------------------------------------------------------------
 
  1357 // CCmPluginBaseEng::FindWAPRecordL
 
  1365 // CCmPluginBaseEng::FindWAPRecordL
 
  1358 // ---------------------------------------------------------------------------
 
  1366 // ---------------------------------------------------------------------------
 
  1360 CCDWAPIPBearerRecord* CCmPluginBaseEng::FindWAPRecordL()
 
  1368 CCDWAPIPBearerRecord* CCmPluginBaseEng::FindWAPRecordL()
 
  1361     {
 
  1369     {
 
  1362     OstTraceFunctionEntry0( CCMPLUGINBASEENG_FINDWAPRECORDL_ENTRY );
 
  1370     OstTraceFunctionEntry0( CCMPLUGINBASEENG_FINDWAPRECORDL_ENTRY );
 
  1363 
  1371 
  1364     CMDBRecordSet<CCDWAPIPBearerRecord>* wapRS =
 
  1372     CMDBRecordSet<CCDWAPIPBearerRecord>* wapRS =
 
  1365             new(ELeave)
 
  1373             new( ELeave ) CMDBRecordSet<CCDWAPIPBearerRecord>( KCDTIdWAPIPBearerRecord );
 
  1366                    CMDBRecordSet<CCDWAPIPBearerRecord>(KCDTIdWAPIPBearerRecord);
 
       
  1367     CleanupStack::PushL( wapRS );
 
  1374     CleanupStack::PushL( wapRS );
 
  1368 
  1375 
  1369     CCDWAPIPBearerRecord* wapBearerRecord = static_cast<CCDWAPIPBearerRecord *>
 
  1376     CCDWAPIPBearerRecord* wapBearerRecord = static_cast<CCDWAPIPBearerRecord*>(
 
  1370                       (CCDRecordBase::RecordFactoryL(KCDTIdWAPIPBearerRecord));
 
  1377             CCDRecordBase::RecordFactoryL( KCDTIdWAPIPBearerRecord ) );
 
  1371 
  1378 
  1372     CleanupStack::PushL( wapBearerRecord );
 
  1379     CleanupStack::PushL( wapBearerRecord );
 
  1373 
  1380 
  1374     wapBearerRecord->iWAPIAP = iIapId;
 
  1381     wapBearerRecord->iWAPIAP = iIapId;
 
  1375     wapRS->iRecords.AppendL( wapBearerRecord );
 
  1382     wapRS->iRecords.AppendL( wapBearerRecord );
 
  1376 
  1383 
  1377     CleanupStack::Pop( wapBearerRecord );
 
  1384     CleanupStack::Pop( wapBearerRecord );
 
  1378     wapBearerRecord = NULL;
 
  1385     wapBearerRecord = NULL;
 
  1379 
  1386 
  1380     if ( wapRS->FindL(iSession) )
 
  1387     if ( wapRS->FindL( iSession ) )
 
  1381         {
 
  1388         {
 
  1382         wapBearerRecord =
 
  1389         wapBearerRecord = static_cast<CCDWAPIPBearerRecord*>( wapRS->iRecords[0] );
 
  1383                         static_cast<CCDWAPIPBearerRecord *>(wapRS->iRecords[0]);
 
  1390 
  1384 
  1391         // Take over the ownership of this record.
 
  1385         // we take over the ownership of this record
 
       
  1386         wapRS->iRecords.Remove( 0 );
 
  1392         wapRS->iRecords.Remove( 0 );
 
  1387         }
 
  1393         }
 
  1388 
  1394 
  1389     CleanupStack::PopAndDestroy( wapRS );
 
  1395     CleanupStack::PopAndDestroy( wapRS );
 
  1390 
  1396 
  1391     OstTraceFunctionExit0( CCMPLUGINBASEENG_FINDWAPRECORDL_EXIT );
 
  1397     OstTraceFunctionExit0( CCMPLUGINBASEENG_FINDWAPRECORDL_EXIT );
 
  1392 
       
  1393     return wapBearerRecord;
 
  1398     return wapBearerRecord;
 
  1394     }
 
  1399     }
 
  1395 
  1400 
  1396 // ---------------------------------------------------------------------------
 
  1401 // ---------------------------------------------------------------------------
 
  1397 // CCmPluginBaseEng::FindSeamlessnessRecordL
 
  1402 // CCmPluginBaseEng::FindSeamlessnessRecordL
 
  1400 CCDIAPMetadataRecord* CCmPluginBaseEng::FindMetadataRecordL()
 
  1405 CCDIAPMetadataRecord* CCmPluginBaseEng::FindMetadataRecordL()
 
  1401     {
 
  1406     {
 
  1402     OstTraceFunctionEntry0( CCMPLUGINBASEENG_FINDSEAMLESSNESSRECORDL_ENTRY );
 
  1407     OstTraceFunctionEntry0( CCMPLUGINBASEENG_FINDSEAMLESSNESSRECORDL_ENTRY );
 
  1403 
  1408 
  1404     CMDBRecordSet<CCDIAPMetadataRecord>* metadataRecordSet =
 
  1409     CMDBRecordSet<CCDIAPMetadataRecord>* metadataRecordSet =
 
  1405           new(ELeave) CMDBRecordSet<CCDIAPMetadataRecord>( iMetadataTableId );
 
  1410             new( ELeave ) CMDBRecordSet<CCDIAPMetadataRecord>( iMetadataTableId );
 
  1406     CleanupStack::PushL( metadataRecordSet );
 
  1411     CleanupStack::PushL( metadataRecordSet );
 
  1407 
  1412 
  1408     CCDIAPMetadataRecord* metadataRecord =
 
  1413     CCDIAPMetadataRecord* metadataRecord =
 
  1409             new (ELeave) CCDIAPMetadataRecord( iMetadataTableId );
 
  1414             new( ELeave ) CCDIAPMetadataRecord( iMetadataTableId );
 
  1410 
       
  1411     CleanupStack::PushL( metadataRecord );
 
  1415     CleanupStack::PushL( metadataRecord );
 
  1412 
  1416 
  1413     metadataRecord->iIAP = IAPRecordElementId();
 
  1417     metadataRecord->iIAP = IAPRecordElementId();
 
  1414     metadataRecordSet->iRecords.AppendL( metadataRecord );
 
  1418     metadataRecordSet->iRecords.AppendL( metadataRecord );
 
  1415 
  1419 
  1432         }
 
  1436         }
 
  1433 
  1437 
  1434     CleanupStack::PopAndDestroy( metadataRecordSet );
 
  1438     CleanupStack::PopAndDestroy( metadataRecordSet );
 
  1435 
  1439 
  1436     OstTraceFunctionExit0( CCMPLUGINBASEENG_FINDSEAMLESSNESSRECORDL_EXIT );
 
  1440     OstTraceFunctionExit0( CCMPLUGINBASEENG_FINDSEAMLESSNESSRECORDL_EXIT );
 
  1437 
       
  1438     return metadataRecord;
 
  1441     return metadataRecord;
 
  1439     }
 
  1442     }
 
  1440 
  1443 
  1441 // ---------------------------------------------------------------------------
 
  1444 // ---------------------------------------------------------------------------
 
  1442 // CCmPluginBaseEng::DoMakeValidNameL
 
  1445 // CCmPluginBaseEng::DoMakeValidNameL
 
  1443 // ---------------------------------------------------------------------------
 
  1446 // ---------------------------------------------------------------------------
 
  1444 //
 
  1447 //
 
  1445 HBufC* CCmPluginBaseEng::DoMakeValidNameL( const TDesC& aName,
 
  1448 HBufC* CCmPluginBaseEng::DoMakeValidNameL(
 
  1446                                            const TUint32& aIapId  )
 
  1449         const TDesC& aName,
 
       
  1450         const TUint32& aIapId )
 
  1447     {
 
  1451     {
 
  1448     OstTraceFunctionEntry0( CCMPLUGINBASEENG_DOMAKEVALIDNAMEL_ENTRY );
 
  1452     OstTraceFunctionEntry0( CCMPLUGINBASEENG_DOMAKEVALIDNAMEL_ENTRY );
 
  1449 
  1453 
  1450     TBool changed( EFalse );
 
  1454     TBool changed( EFalse );
 
  1451     HBufC* temp = HBufC::NewLC( KApMaxConnNameLength );
 
  1455     HBufC* temp = HBufC::NewLC( KApMaxConnNameLength );
 
  1467         valid = IsValidNameL( *temp, aIapId );
 
  1471         valid = IsValidNameL( *temp, aIapId );
 
  1468         if ( !valid )
 
  1472         if ( !valid )
 
  1469             {
 
  1473             {
 
  1470             changed = ETrue;
 
  1474             changed = ETrue;
 
  1471             postfix++;
 
  1475             postfix++;
 
  1472             // check the length of postfix, check text length accordingly
 
  1476             // Check the length of postfix, check text length accordingly.
 
  1473             pf = postfix;
 
  1477             pf = postfix;
 
  1474             for (i=1; i<10; i++)
 
  1478             for ( i = 1; i < 10; i++ )
 
  1475                 {
 
  1479                 {
 
  1476                 pf /= 10;
 
  1480                 pf /= 10;
 
  1477                 if ( !pf )
 
  1481                 if ( !pf )
 
  1478                     break;
 
  1482                     break;
 
  1479                 }
 
  1483                 }
 
  1494                 {
 
  1498                 {
 
  1495                 sgdptr2 = prefix.Left( KApMaxConnNameLength );
 
  1499                 sgdptr2 = prefix.Left( KApMaxConnNameLength );
 
  1496                 }
 
  1500                 }
 
  1497             if ( postfix )
 
  1501             if ( postfix )
 
  1498                 {
 
  1502                 {
 
  1499                 TBuf< KMaxPostfixLength > postfixString;
 
  1503                 TBuf<KMaxPostfixLength> postfixString;
 
  1500                 if ( postfix > 9 )
 
  1504                 if ( postfix > 9 )
 
  1501                     {
 
  1505                     {
 
  1502                     postfixString.Format( KFormatLargePostfix, postfix );
 
  1506                     postfixString.Format( KFormatLargePostfix, postfix );
 
  1503 //     TODO:               AknTextUtils::LanguageSpecificNumberConversion( postfixString );
 
  1507 //     TODO:               AknTextUtils::LanguageSpecificNumberConversion( postfixString );
 
  1504                     }
 
  1508                     }
 
  1505                 else
 
  1509                 else
 
  1506                     {
 
  1510                     {
 
  1507                     postfixString.Format( KFormatPostfix, postfix );
 
  1511                     postfixString.Format( KFormatPostfix, postfix );
 
  1508 //     TODO:               AknTextUtils::LanguageSpecificNumberConversion( postfixString );
 
  1512 //     TODO:               AknTextUtils::LanguageSpecificNumberConversion( postfixString );
 
  1509                     }
 
  1513                     }
 
  1510                 sgdptr.Format( KFormatNameWithPostfix, &sgdptr2,
 
  1514                 sgdptr.Format( KFormatNameWithPostfix, &sgdptr2, &postfixString );
 
  1511                                    &postfixString );
 
       
  1512                 }
 
  1515                 }
 
  1513             else
 
  1516             else
 
  1514                 {
 
  1517                 {
 
  1515                 sgdptr.Format( KFormatNoPostfix, &sgdptr2 );
 
  1518                 sgdptr.Format( KFormatNoPostfix, &sgdptr2 );
 
  1516                 }
 
  1519                 }
 
  1529         CleanupStack::PopAndDestroy( temp );
 
  1532         CleanupStack::PopAndDestroy( temp );
 
  1530         temp = NULL;
 
  1533         temp = NULL;
 
  1531         }
 
  1534         }
 
  1532 
  1535 
  1533     OstTraceFunctionExit0( CCMPLUGINBASEENG_DOMAKEVALIDNAMEL_EXIT );
 
  1536     OstTraceFunctionExit0( CCMPLUGINBASEENG_DOMAKEVALIDNAMEL_EXIT );
 
  1534 
       
  1535     return temp;
 
  1537     return temp;
 
  1536     }
 
  1538     }
 
  1537 
  1539 
  1538 // ---------------------------------------------------------------------------
 
  1540 // ---------------------------------------------------------------------------
 
  1539 // CCmPluginBaseEng::EnsureMaxLengthLC
 
  1541 // CCmPluginBaseEng::EnsureMaxLengthLC
 
  1540 // ---------------------------------------------------------------------------
 
  1542 // ---------------------------------------------------------------------------
 
  1541 //
 
  1543 //
 
  1542 HBufC* CCmPluginBaseEng::EnsureMaxLengthLC( const TDesC& aName,
 
  1544 HBufC* CCmPluginBaseEng::EnsureMaxLengthLC(
 
  1543                                             TBool& aChanged )
 
  1545         const TDesC& aName,
 
       
  1546         TBool& aChanged )
 
  1544     {
 
  1547     {
 
  1545     OstTraceFunctionEntry0( CCMPLUGINBASEENG_ENSUREMAXLENGTHLC_ENTRY );
 
  1548     OstTraceFunctionEntry0( CCMPLUGINBASEENG_ENSUREMAXLENGTHLC_ENTRY );
 
  1546 
  1549 
  1547     TInt length = aName.Length();
 
  1550     TInt length = aName.Length();
 
  1548 
  1551 
  1554         User::Leave( KErrArgument );
 
  1557         User::Leave( KErrArgument );
 
  1555         }
 
  1558         }
 
  1556 
  1559 
  1557     HBufC* corrname;
 
  1560     HBufC* corrname;
 
  1558     if ( KApMaxConnNameLength < length )
 
  1561     if ( KApMaxConnNameLength < length )
 
  1559         { // name too long, truncate.
 
  1562         {
 
       
  1563         // Name too long, truncate.
 
  1560         corrname = aName.Left( KApMaxConnNameLength ).AllocLC();
 
  1564         corrname = aName.Left( KApMaxConnNameLength ).AllocLC();
 
  1561         aChanged = ETrue;
 
  1565         aChanged = ETrue;
 
  1562         }
 
  1566         }
 
  1563     else
 
  1567     else
 
  1564         {
 
  1568         {
 
  1566         corrname->Des().Trim();
 
  1570         corrname->Des().Trim();
 
  1567         if ( corrname->Length() == 0 )
 
  1571         if ( corrname->Length() == 0 )
 
  1568             {
 
  1572             {
 
  1569             User::Leave( KErrArgument );
 
  1573             User::Leave( KErrArgument );
 
  1570             }
 
  1574             }
 
  1571         // comes here only if name is valid
 
  1575         // Comes here only if name is valid.
 
  1572         if ( corrname->Length() != aName.Length() )
 
  1576         if ( corrname->Length() != aName.Length() )
 
  1573             {
 
  1577             {
 
  1574             aChanged = ETrue;
 
  1578             aChanged = ETrue;
 
  1575             }
 
  1579             }
 
  1576         }
 
  1580         }
 
  1577 
  1581 
  1578     OstTraceFunctionExit0( CCMPLUGINBASEENG_ENSUREMAXLENGTHLC_EXIT );
 
  1582     OstTraceFunctionExit0( CCMPLUGINBASEENG_ENSUREMAXLENGTHLC_EXIT );
 
  1579 
       
  1580     return corrname;
 
  1583     return corrname;
 
  1581     }
 
  1584     }
 
  1582 
  1585 
  1583 // ---------------------------------------------------------------------------
 
  1586 // ---------------------------------------------------------------------------
 
  1584 // Given aName in the format <prefix> or <prefix><brace><integer><brace>,
 
  1587 // Given aName in the format <prefix> or <prefix><brace><integer><brace>,
 
  1611             {
 
  1614             {
 
  1612             // Yes, the trailer is an integer.
 
  1615             // Yes, the trailer is an integer.
 
  1613             prefix.Set( aName.Left( lastBrace ) );
 
  1616             prefix.Set( aName.Left( lastBrace ) );
 
  1614             }
 
  1617             }
 
  1615         }
 
  1618         }
 
       
  1619 
  1616     OstTraceFunctionExit0( CCMPLUGINBASEENG_GETPREFIX_EXIT );
 
  1620     OstTraceFunctionExit0( CCMPLUGINBASEENG_GETPREFIX_EXIT );
 
  1617 
       
  1618     return prefix;
 
  1621     return prefix;
 
  1619     }
 
  1622     }
 
  1620 
  1623 
  1621 
  1624 
  1622 // ---------------------------------------------------------------------------
 
  1625 // ---------------------------------------------------------------------------
 
  1680                 {
 
  1683                 {
 
  1681                 postfix = -1;
 
  1684                 postfix = -1;
 
  1682                 }
 
  1685                 }
 
  1683             }
 
  1686             }
 
  1684         }
 
  1687         }
 
       
  1688 
  1685     OstTraceFunctionExit0( CCMPLUGINBASEENG_GETPOSTFIX_EXIT );
 
  1689     OstTraceFunctionExit0( CCMPLUGINBASEENG_GETPOSTFIX_EXIT );
 
  1686 
       
  1687     return postfix;
 
  1690     return postfix;
 
  1688     }
 
  1691     }
 
  1689 
  1692 
  1690 // ---------------------------------------------------------------------------
 
  1693 // ---------------------------------------------------------------------------
 
  1691 // CCmPluginBaseEng::IsValidNameL
 
  1694 // CCmPluginBaseEng::IsValidNameL
 
  1692 // ---------------------------------------------------------------------------
 
  1695 // ---------------------------------------------------------------------------
 
  1693 //
 
  1696 //
 
  1694 TBool CCmPluginBaseEng::IsValidNameL( const TDesC& aNameText,
 
  1697 TBool CCmPluginBaseEng::IsValidNameL(
 
  1695                                       const TUint32& aIapId )
 
  1698         const TDesC& aNameText,
 
       
  1699         const TUint32& aIapId )
 
  1696     {
 
  1700     {
 
  1697     OstTraceFunctionEntry0( CCMPLUGINBASEENG_ISVALIDNAMEL_ENTRY );
 
  1701     OstTraceFunctionEntry0( CCMPLUGINBASEENG_ISVALIDNAMEL_ENTRY );
 
  1698 
  1702 
  1699     TBool retVal( ETrue );
 
  1703     TBool retVal( ETrue );
 
  1700 
  1704 
  1701     CMDBRecordSet<CCDIAPRecord>* iapRS =
 
  1705     CMDBRecordSet<CCDIAPRecord>* iapRS =
 
  1702                       new(ELeave) CMDBRecordSet<CCDIAPRecord>(KCDTIdIAPRecord);
 
  1706             new( ELeave ) CMDBRecordSet<CCDIAPRecord>(KCDTIdIAPRecord);
 
  1703     CleanupStack::PushL(iapRS);
 
  1707     CleanupStack::PushL(iapRS);
 
  1704 
  1708 
  1705     CCDIAPRecord* iapRecord = static_cast<CCDIAPRecord *>
 
  1709     CCDIAPRecord* iapRecord = static_cast<CCDIAPRecord*>(
 
  1706                             (CCDRecordBase::RecordFactoryL(KCDTIdIAPRecord));
 
  1710             CCDRecordBase::RecordFactoryL( KCDTIdIAPRecord ) );
 
  1707 
       
  1708     CleanupStack::PushL( iapRecord );
 
  1711     CleanupStack::PushL( iapRecord );
 
  1709 
  1712 
  1710     // Prime record
 
  1713     // Prime record.
 
  1711     iapRecord->iRecordName.SetL( aNameText );
 
  1714     iapRecord->iRecordName.SetL( aNameText );
 
  1712 
       
  1713     iapRS->iRecords.AppendL( iapRecord );
 
  1715     iapRS->iRecords.AppendL( iapRecord );
 
  1714 
       
  1715     CleanupStack::Pop( iapRecord );
 
  1716     CleanupStack::Pop( iapRecord );
 
  1716 
       
  1717     iapRecord = NULL;
 
  1717     iapRecord = NULL;
 
  1718 
  1718 
  1719     if ( iapRS->FindL(iSession) )
 
  1719     if ( iapRS->FindL( iSession ) )
 
  1720         {
 
  1720         {
 
  1721         if ( iIapId )
 
  1721         if ( iIapId )
 
  1722             // this is not a new CM
 
  1722             {
 
  1723             {
 
  1723             // This is not a new CM.
 
  1724             for ( TInt i = 0; i < iapRS->iRecords.Count(); ++i )
 
  1724             for ( TInt i = 0; i < iapRS->iRecords.Count(); ++i )
 
  1725                 {
 
  1725                 {
 
  1726                 if ( iapRS->iRecords[i]->RecordId() != aIapId )
 
  1726                 if ( iapRS->iRecords[i]->RecordId() != aIapId )
 
  1727                     // duplication because it's not our name
 
       
  1728                     {
 
  1727                     {
 
       
  1728                     // Duplication because it's not our name.
 
  1729                     retVal = EFalse;
 
  1729                     retVal = EFalse;
 
  1730                     break;
 
  1730                     break;
 
  1731                     }
 
  1731                     }
 
  1732                 }
 
  1732                 }
 
  1733             }
 
  1733             }
 
  1734         else
 
  1734         else
 
  1735             // new CM -> any occurence is a duplication
 
  1735             {
 
  1736             {
 
  1736             // New CM -> any occurence is a duplication.
 
  1737             retVal = EFalse;
 
  1737             retVal = EFalse;
 
  1738             }
 
  1738             }
 
  1739         }
 
  1739         }
 
  1740 
  1740 
  1741     CleanupStack::PopAndDestroy( iapRS );
 
  1741     CleanupStack::PopAndDestroy( iapRS );
 
  1742 
  1742 
  1743     OstTraceFunctionExit0( CCMPLUGINBASEENG_ISVALIDNAMEL_EXIT );
 
  1743     OstTraceFunctionExit0( CCMPLUGINBASEENG_ISVALIDNAMEL_EXIT );
 
  1744 
       
  1745     return retVal;
 
  1744     return retVal;
 
  1746     }
 
  1745     }
 
  1747 
  1746 
  1748 // ---------------------------------------------------------------------------
 
  1747 // ---------------------------------------------------------------------------
 
  1749 // CCmPluginBaseEng::EscapeTextLC
 
  1748 // CCmPluginBaseEng::EscapeTextLC
 
  1758     HBufC* retbuf = HBufC::NewLC( 2*l );
 
  1757     HBufC* retbuf = HBufC::NewLC( 2*l );
 
  1759     TPtr ret = retbuf->Des();
 
  1758     TPtr ret = retbuf->Des();
 
  1760     TUint quote( '\'' );  // TChar gives warnings in THUMB & ARMI
 
  1759     TUint quote( '\'' );  // TChar gives warnings in THUMB & ARMI
 
  1761     TInt i( 0 );
 
  1760     TInt i( 0 );
 
  1762 
  1761 
  1763     for ( i=0; i<l; i++ )
 
  1762     for ( i = 0; i < l; i++ )
 
  1764         {
 
  1763         {
 
  1765         ret.Append( aLiteral[i] );
 
  1764         ret.Append( aLiteral[i] );
 
  1766         if ( aLiteral[i] == quote )
 
  1765         if ( aLiteral[i] == quote )
 
  1767             {
 
  1766             {
 
  1768             // Duplicate quote.
 
  1767             // Duplicate quote.
 
  1769             ret.Append( quote );
 
  1768             ret.Append( quote );
 
  1770             }
 
  1769             }
 
  1771         }
 
  1770         }
 
       
  1771 
  1772     OstTraceFunctionExit0( CCMPLUGINBASEENG_ESCAPETEXTLC_EXIT );
 
  1772     OstTraceFunctionExit0( CCMPLUGINBASEENG_ESCAPETEXTLC_EXIT );
 
  1773 
       
  1774     return retbuf;
 
  1773     return retbuf;
 
  1775     }
 
  1774     }
 
  1776 
  1775 
  1777 // ---------------------------------------------------------------------------
 
  1776 // ---------------------------------------------------------------------------
 
  1778 // CCmPluginBaseEng::SetDefaultNameL
 
  1777 // CCmPluginBaseEng::SetDefaultNameL
 
  1789     else if ( iNamingMethod == ENamingUnique )
 
  1788     else if ( iNamingMethod == ENamingUnique )
 
  1790         {
 
  1789         {
 
  1791         HBufC* newName = DoMakeValidNameL( aName, iIapId );
 
  1790         HBufC* newName = DoMakeValidNameL( aName, iIapId );
 
  1792 
  1791 
  1793         if ( newName )
 
  1792         if ( newName )
 
  1794             // name converted to unique
 
  1793             // Name converted to unique.
 
  1795             {
 
  1794             {
 
  1796             CleanupStack::PushL( newName );
 
  1795             CleanupStack::PushL( newName );
 
  1797             iIapRecord->iRecordName.SetL( *newName );
 
  1796             iIapRecord->iRecordName.SetL( *newName );
 
  1798             CleanupStack::PopAndDestroy( newName );
 
  1797             CleanupStack::PopAndDestroy( newName );
 
  1799             }
 
  1798             }
 
  1815         }
 
  1814         }
 
  1816     else
 
  1815     else
 
  1817         {
 
  1816         {
 
  1818         User::Leave( KErrCorrupt );
 
  1817         User::Leave( KErrCorrupt );
 
  1819         }
 
  1818         }
 
       
  1819 
  1820     OstTraceFunctionExit0( CCMPLUGINBASEENG_SETDEFAULTNAMEL_EXIT );
 
  1820     OstTraceFunctionExit0( CCMPLUGINBASEENG_SETDEFAULTNAMEL_EXIT );
 
  1821     }
 
  1821     }
 
  1822 
  1822 
  1823 // ---------------------------------------------------------------------------
 
  1823 // ---------------------------------------------------------------------------
 
  1824 // CCmPluginBaseEng::SetNameL
 
  1824 // CCmPluginBaseEng::SetNameL
 
  1839         {
 
  1839         {
 
  1840         TUint32 iapid = aIapRecord->RecordId();
 
  1840         TUint32 iapid = aIapRecord->RecordId();
 
  1841         HBufC* newName = DoMakeValidNameL( aName, iapid );
 
  1841         HBufC* newName = DoMakeValidNameL( aName, iapid );
 
  1842 
  1842 
  1843         if ( newName )
 
  1843         if ( newName )
 
  1844             // name converted to unique
 
  1844             // Name converted to unique.
 
  1845             {
 
  1845             {
 
  1846             CleanupStack::PushL( newName );
 
  1846             CleanupStack::PushL( newName );
 
  1847             aIapRecord->iRecordName.SetL( *newName );
 
  1847             aIapRecord->iRecordName.SetL( *newName );
 
  1848             CleanupStack::PopAndDestroy( newName );
 
  1848             CleanupStack::PopAndDestroy( newName );
 
  1849             }
 
  1849             }
 
  1878         CCDRecordBase* aSrcRecord,
 
  1878         CCDRecordBase* aSrcRecord,
 
  1879         CCDRecordBase* aDestRecord ) const
 
  1879         CCDRecordBase* aDestRecord ) const
 
  1880     {
 
  1880     {
 
  1881     OstTraceFunctionEntry0( CCMPLUGINBASEENG_CHECKIFNAMEMODIFIEDL_ENTRY );
 
  1881     OstTraceFunctionEntry0( CCMPLUGINBASEENG_CHECKIFNAMEMODIFIEDL_ENTRY );
 
  1882 
  1882 
       
  1883     if ( !aSrcRecord || !aDestRecord )
 
       
  1884         {
 
       
  1885         User::Leave( KErrCorrupt );
 
       
  1886         }
 
       
  1887 
  1883     if ( !TPtrC( aSrcRecord->iRecordName ).CompareF( TPtrC( aDestRecord->iRecordName ) ) )
 
  1888     if ( !TPtrC( aSrcRecord->iRecordName ).CompareF( TPtrC( aDestRecord->iRecordName ) ) )
 
  1884         // names matche
 
  1889         {
 
  1885         {
 
  1890         // Names match.
 
  1886         OstTraceFunctionExit0( CCMPLUGINBASEENG_CHECKIFNAMEMODIFIEDL_EXIT );
 
  1891         OstTraceFunctionExit0( CCMPLUGINBASEENG_CHECKIFNAMEMODIFIEDL_EXIT );
 
  1887         return;
 
  1892         return;
 
  1888         }
 
  1893         }
 
  1889 
  1894 
  1890     aDestRecord->iRecordName.SetL( TPtrC( aSrcRecord->iRecordName ) );
 
  1895     aDestRecord->iRecordName.SetL( TPtrC( aSrcRecord->iRecordName ) );
 
  1895 // ---------------------------------------------------------------------------
 
  1900 // ---------------------------------------------------------------------------
 
  1896 // CCmPluginBaseEng::IAPRecordElementId
 
  1901 // CCmPluginBaseEng::IAPRecordElementId
 
  1897 // ---------------------------------------------------------------------------
 
  1902 // ---------------------------------------------------------------------------
 
  1898 TMDBElementId CCmPluginBaseEng::IAPRecordElementId() const
 
  1903 TMDBElementId CCmPluginBaseEng::IAPRecordElementId() const
 
  1899     {
 
  1904     {
 
  1900     OstTraceFunctionEntry0( CCMPLUGINBASEENG_IAPRECORDELEMENTID_ENTRY );
 
       
  1901 
       
  1902     return ( KCDMaskShowField & iIapRecord->ElementId() );
 
  1905     return ( KCDMaskShowField & iIapRecord->ElementId() );
 
  1903     }
 
  1906     }
 
  1904 
  1907 
  1905 // ---------------------------------------------------------------------------
 
  1908 // ---------------------------------------------------------------------------
 
  1906 // CCmPluginBaseEng::IsProtected
 
  1909 // CCmPluginBaseEng::IsProtected
 
  1919     {
 
  1922     {
 
  1920     OstTraceFunctionEntry0( CCMPLUGINBASEENG_GETLOCATIONIDL_ENTRY );
 
  1923     OstTraceFunctionEntry0( CCMPLUGINBASEENG_GETLOCATIONIDL_ENTRY );
 
  1921 
  1924 
  1922     TUint32 locId( 0 );
 
  1925     TUint32 locId( 0 );
 
  1923     CMDBRecordSet<CCDLocationRecord>* locRS =
 
  1926     CMDBRecordSet<CCDLocationRecord>* locRS =
 
  1924             new(ELeave) CMDBRecordSet<CCDLocationRecord>(KCDTIdLocationRecord);
 
  1927             new( ELeave ) CMDBRecordSet<CCDLocationRecord>( KCDTIdLocationRecord );
 
  1925     CleanupStack::PushL( locRS );
 
  1928     CleanupStack::PushL( locRS );
 
  1926 
  1929 
  1927     CCDLocationRecord* locRecord = static_cast<CCDLocationRecord *>
 
  1930     CCDLocationRecord* locRecord = static_cast<CCDLocationRecord*>(
 
  1928                          (CCDRecordBase::RecordFactoryL(KCDTIdLocationRecord));
 
  1931             CCDRecordBase::RecordFactoryL( KCDTIdLocationRecord ) );
 
  1929 
       
  1930     CleanupStack::PushL( locRecord );
 
  1932     CleanupStack::PushL( locRecord );
 
       
  1933 
  1931     locRecord->iRecordName.SetL( KLocationName );
 
  1934     locRecord->iRecordName.SetL( KLocationName );
 
  1932     locRS->iRecords.AppendL( locRecord );
 
  1935     locRS->iRecords.AppendL( locRecord );
 
  1933     CleanupStack::Pop( locRecord );
 
  1936     CleanupStack::Pop( locRecord );
 
  1934 
  1937 
  1935     if ( locRS->FindL(iSession) )
 
  1938     if ( locRS->FindL(iSession) )
 
  1936         {
 
  1939         {
 
  1937         locRecord = static_cast<CCDLocationRecord *>(locRS->iRecords[0]);
 
  1940         locRecord = static_cast<CCDLocationRecord*>( locRS->iRecords[0] );
 
  1938 
       
  1939         locId = locRecord->RecordId();
 
  1941         locId = locRecord->RecordId();
 
  1940         }
 
  1942         }
 
  1941     else
 
  1943     else
 
  1942         {
 
  1944         {
 
  1943         User::Leave( KErrNotFound );
 
  1945         User::Leave( KErrNotFound ); //TODO, what to do if not found. Can we create it? need study.
 
  1944         }
 
  1946         }
 
  1945 
  1947 
  1946     CleanupStack::PopAndDestroy( locRS );
 
  1948     CleanupStack::PopAndDestroy( locRS );
 
  1947 
  1949 
  1948     OstTraceFunctionExit0( CCMPLUGINBASEENG_GETLOCATIONIDL_EXIT );
 
  1950     OstTraceFunctionExit0( CCMPLUGINBASEENG_GETLOCATIONIDL_EXIT );
 
  1949 
       
  1950     return locId;
 
  1951     return locId;
 
  1951     }
 
  1952     }
 
  1952 
  1953 
  1953 // ---------------------------------------------------------------------------
 
  1954 // ---------------------------------------------------------------------------
 
  1954 // CCmPluginBaseEng::SetProxyServerNameL
 
  1955 // CCmPluginBaseEng::SetProxyServerNameL
 
  1955 // ---------------------------------------------------------------------------
 
  1956 // ---------------------------------------------------------------------------
 
  1956  void CCmPluginBaseEng::SetProxyServerNameL( const TDesC& aProxyServer,
 
  1957  void CCmPluginBaseEng::SetProxyServerNameL(
 
  1957                                              CCDRecordBase* aProxyRecord )
 
  1958          const TDesC& aProxyServer,
 
       
  1959          CCDRecordBase* aProxyRecord )
 
  1958     {
 
  1960     {
 
  1959     OstTraceFunctionEntry0( CCMPLUGINBASEENG_SETPROXYSERVERNAMEL_ENTRY );
 
  1961     OstTraceFunctionEntry0( CCMPLUGINBASEENG_SETPROXYSERVERNAMEL_ENTRY );
 
  1960 
  1962 
  1961     CCDProxiesRecord* proxyRecord =
 
  1963     CCDProxiesRecord* proxyRecord = static_cast<CCDProxiesRecord*>( aProxyRecord );
 
  1962                     static_cast<CCDProxiesRecord*>( aProxyRecord );
 
       
  1963 
  1964 
  1964     proxyRecord->iServerName.SetL( aProxyServer );
 
  1965     proxyRecord->iServerName.SetL( aProxyServer );
 
  1965     if ( !aProxyServer.Length() )
 
  1966     if ( !aProxyServer.Length() )
 
  1966         {
 
  1967         {
 
  1967         proxyRecord->iPortNumber = 0;
 
  1968         proxyRecord->iPortNumber = 0;
 
  1977 
  1978 
  1978 // ---------------------------------------------------------------------------
 
  1979 // ---------------------------------------------------------------------------
 
  1979 // CCmPluginBaseEng::CheckDNSServerAddressL
 
  1980 // CCmPluginBaseEng::CheckDNSServerAddressL
 
  1980 // ---------------------------------------------------------------------------
 
  1981 // ---------------------------------------------------------------------------
 
  1981 //
 
  1982 //
 
  1982 EXPORT_C void CCmPluginBaseEng::CheckDNSServerAddressL( TBool aIPv6,
 
  1983 EXPORT_C void CCmPluginBaseEng::CheckDNSServerAddressL(
 
  1983                                                         CMDBField<TDesC>& aDNS1,
 
  1984         TBool aIPv6,
 
  1984                                                         CMDBField<TDesC>& aDNS2,
 
  1985         CMDBField<TDesC>& aDNS1,
 
  1985                                                         CMDBField<TBool>& aDNSFromServer )
 
  1986         CMDBField<TDesC>& aDNS2,
 
       
  1987         CMDBField<TBool>& aDNSFromServer )
 
  1986     {
 
  1988     {
 
  1987     OstTraceFunctionEntry0( CCMPLUGINBASEENG_CHECKDNSSERVERADDRESSL_ENTRY );
 
  1989     OstTraceFunctionEntry0( CCMPLUGINBASEENG_CHECKDNSSERVERADDRESSL_ENTRY );
 
  1988 
  1990 
  1989     if ( !aDNSFromServer )
 
  1991     if ( !aDNSFromServer )
 
  1990         {
 
  1992         {
 
  1997                     aDNS1.SetL( aDNS2 );
 
  1999                     aDNS1.SetL( aDNS2 );
 
  1998                     aDNS2.SetL( KDynamicIpv6Address );
 
  2000                     aDNS2.SetL( KDynamicIpv6Address );
 
  1999                     }
 
  2001                     }
 
  2000                 else
 
  2002                 else
 
  2001                     {
 
  2003                     {
 
  2002                     // Both are unspecified
 
  2004                     // Both are unspecified.
 
  2003                     aDNSFromServer = ETrue;
 
  2005                     aDNSFromServer = ETrue;
 
  2004                     }
 
  2006                     }
 
  2005                 }
 
  2007                 }
 
  2006             }
 
  2008             }
 
  2007         else // IPv4
 
  2009         else // IPv4
 
  2013                     aDNS1.SetL( aDNS2 );
 
  2015                     aDNS1.SetL( aDNS2 );
 
  2014                     aDNS2.SetL( KUnspecifiedIPv4 );
 
  2016                     aDNS2.SetL( KUnspecifiedIPv4 );
 
  2015                     }
 
  2017                     }
 
  2016                 else
 
  2018                 else
 
  2017                     {
 
  2019                     {
 
  2018                     // Both are unspecified
 
  2020                     // Both are unspecified.
 
  2019                     aDNSFromServer = ETrue;
 
  2021                     aDNSFromServer = ETrue;
 
  2020                     }
 
  2022                     }
 
  2021                 }
 
  2023                 }
 
  2022             }
 
  2024             }
 
  2023         }
 
  2025         }
 
  2044     aClientPluginInstance->iNamingMethod = iNamingMethod;
 
  2046     aClientPluginInstance->iNamingMethod = iNamingMethod;
 
  2045     aClientPluginInstance->iLocationEnabled = iLocationEnabled;
 
  2047     aClientPluginInstance->iLocationEnabled = iLocationEnabled;
 
  2046 
  2048 
  2047     if ( iIapRecord )
 
  2049     if ( iIapRecord )
 
  2048         {
 
  2050         {
 
  2049         CCDIAPRecord* iapRecord =
 
  2051         CCDIAPRecord* iapRecord = static_cast<CCDIAPRecord*>(
 
  2050                 static_cast<CCDIAPRecord*>( CCDRecordBase::CreateCopyRecordL( *iIapRecord ) );
 
  2052                 CCDRecordBase::CreateCopyRecordL( *iIapRecord ) );
 
       
  2053         iapRecord->SetElementId( iIapRecord->ElementId() );
 
  2051         CleanupStack::PushL( iapRecord );
 
  2054         CleanupStack::PushL( iapRecord );
 
  2052         iapRecord->SetElementId( iIapRecord->ElementId() );
 
  2055         aClientPluginInstance->iGenRecordArray.AppendL(
 
  2053         aClientPluginInstance->iGenRecordArray.AppendL( static_cast<CommsDat::CCDRecordBase*>( iapRecord ) );
 
  2056                 static_cast<CommsDat::CCDRecordBase*>( iapRecord ) );
 
  2054         CleanupStack::Pop( iapRecord );
 
  2057         CleanupStack::Pop( iapRecord );
 
  2055         }
 
  2058         }
 
  2056     else
 
  2059     else
 
  2057         {
 
  2060         {
 
  2058         User::Leave( KErrNotFound );
 
  2061         User::Leave( KErrNotFound );
 
  2071         User::Leave( KErrNotFound );
 
  2074         User::Leave( KErrNotFound );
 
  2072         }
 
  2075         }
 
  2073 
  2076 
  2074     if ( iNetworkRecord )
 
  2077     if ( iNetworkRecord )
 
  2075         {
 
  2078         {
 
  2076         CCDNetworkRecord* networkRecord =
 
  2079         CCDNetworkRecord* networkRecord = static_cast<CCDNetworkRecord*>(
 
  2077                 static_cast<CCDNetworkRecord*>( CCDRecordBase::CreateCopyRecordL( *iNetworkRecord ) );
 
  2080                 CCDRecordBase::CreateCopyRecordL( *iNetworkRecord ) );
 
       
  2081         networkRecord->SetElementId( iNetworkRecord->ElementId() );
 
  2078         CleanupStack::PushL( networkRecord );
 
  2082         CleanupStack::PushL( networkRecord );
 
  2079         networkRecord->SetElementId( iNetworkRecord->ElementId() );
 
  2083         aClientPluginInstance->iGenRecordArray.AppendL(
 
  2080         aClientPluginInstance->iGenRecordArray.AppendL( static_cast<CommsDat::CCDRecordBase*>( networkRecord ) );
 
  2084                 static_cast<CommsDat::CCDRecordBase*>( networkRecord ) );
 
  2081         CleanupStack::Pop( networkRecord );
 
  2085         CleanupStack::Pop( networkRecord );
 
  2082         }
 
  2086         }
 
  2083     else
 
  2087     else
 
  2084         {
 
  2088         {
 
  2085         User::Leave( KErrNotFound );
 
  2089         User::Leave( KErrNotFound );
 
  2086         }
 
  2090         }
 
  2087 
  2091 
  2088     if ( iWapAPRecord )
 
  2092     if ( iWapAPRecord )
 
  2089         {
 
  2093         {
 
  2090         CCDWAPAccessPointRecord* wapAPRecord =
 
  2094         CCDWAPAccessPointRecord* wapAPRecord = static_cast<CCDWAPAccessPointRecord*>(
 
  2091                 static_cast<CCDWAPAccessPointRecord*>( CCDRecordBase::CreateCopyRecordL( *iWapAPRecord ) );
 
  2095                 CCDRecordBase::CreateCopyRecordL( *iWapAPRecord ) );
 
       
  2096         wapAPRecord->SetElementId( iWapAPRecord->ElementId() );
 
  2092         CleanupStack::PushL( wapAPRecord );
 
  2097         CleanupStack::PushL( wapAPRecord );
 
  2093         wapAPRecord->SetElementId( iWapAPRecord->ElementId() );
 
  2098         aClientPluginInstance->iGenRecordArray.AppendL(
 
  2094         aClientPluginInstance->iGenRecordArray.AppendL( static_cast<CommsDat::CCDRecordBase*>( wapAPRecord ) );
 
  2099                 static_cast<CommsDat::CCDRecordBase*>( wapAPRecord ) );
 
  2095         CleanupStack::Pop( wapAPRecord );
 
  2100         CleanupStack::Pop( wapAPRecord );
 
  2096         }
 
  2101         }
 
  2097     else
 
  2102     else
 
  2098         {
 
  2103         {
 
  2099         User::Leave( KErrNotFound );
 
  2104         User::Leave( KErrNotFound );
 
  2100         }
 
  2105         }
 
  2101 
  2106 
  2102     if ( iWapIPBearerRecord )
 
  2107     if ( iWapIPBearerRecord )
 
  2103         {
 
  2108         {
 
  2104         CCDWAPIPBearerRecord* wapIPBearerRecord =
 
  2109         CCDWAPIPBearerRecord* wapIPBearerRecord = static_cast<CCDWAPIPBearerRecord*>(
 
  2105                 static_cast<CCDWAPIPBearerRecord*>( CCDRecordBase::CreateCopyRecordL( *iWapIPBearerRecord ) );
 
  2110                 CCDRecordBase::CreateCopyRecordL( *iWapIPBearerRecord ) );
 
       
  2111         wapIPBearerRecord->SetElementId( iWapIPBearerRecord->ElementId() );
 
  2106         CleanupStack::PushL( wapIPBearerRecord );
 
  2112         CleanupStack::PushL( wapIPBearerRecord );
 
  2107         wapIPBearerRecord->SetElementId( iWapIPBearerRecord->ElementId() );
 
  2113         aClientPluginInstance->iGenRecordArray.AppendL(
 
  2108         aClientPluginInstance->iGenRecordArray.AppendL( static_cast<CommsDat::CCDRecordBase*>( wapIPBearerRecord ) );
 
  2114                 static_cast<CommsDat::CCDRecordBase*>( wapIPBearerRecord ) );
 
  2109         CleanupStack::Pop( wapIPBearerRecord );
 
  2115         CleanupStack::Pop( wapIPBearerRecord );
 
  2110         }
 
  2116         }
 
  2111     else
 
  2117     else
 
  2112         {
 
  2118         {
 
  2113         User::Leave( KErrNotFound );
 
  2119         User::Leave( KErrNotFound );
 
  2114         }
 
  2120         }
 
  2115 
  2121 
  2116     if ( iMetaDataRecord )
 
  2122     if ( iMetaDataRecord )
 
  2117         {
 
  2123         {
 
  2118         CCDIAPMetadataRecord* metaDataRecord =
 
  2124         CCDIAPMetadataRecord* metadataRecord =
 
  2119                 new( ELeave ) CCDIAPMetadataRecord( iMetadataTableId );
 
  2125                 new( ELeave ) CCDIAPMetadataRecord( iMetadataTableId );
 
  2120         CleanupStack::PushL( metaDataRecord );
 
  2126         CleanupStack::PushL( metadataRecord );
 
  2121         metaDataRecord->iIAP = IAPRecordElementId();
 
  2127         CopyRecordFieldsL( *iMetaDataRecord, *metadataRecord );
 
  2122         metaDataRecord->iMetadata.SetL( iMetaDataRecord->iMetadata );
 
  2128         metadataRecord->SetElementId( iMetaDataRecord->ElementId() );
 
  2123         metaDataRecord->iSeamlessness.SetL( iMetaDataRecord->iSeamlessness );
 
  2129         // Record name is set/changed during update.
 
  2124         metaDataRecord->SetElementId( iMetaDataRecord->ElementId() );
 
       
  2125         // Record name is set during update.
 
       
  2126 
  2130 
  2127         aClientPluginInstance->iGenRecordArray.AppendL(
 
  2131         aClientPluginInstance->iGenRecordArray.AppendL(
 
  2128                 static_cast<CommsDat::CCDRecordBase*>( metaDataRecord ) );
 
  2132                 static_cast<CommsDat::CCDRecordBase*>( metadataRecord ) );
 
  2129         CleanupStack::Pop( metaDataRecord );
 
  2133         CleanupStack::Pop( metadataRecord );
 
  2130         }
 
  2134         }
 
  2131     else
 
  2135     else
 
  2132         {
 
  2136         {
 
  2133         aClientPluginInstance->iGenRecordArray.AppendL( NULL );
 
  2137         aClientPluginInstance->iGenRecordArray.AppendL( NULL );
 
  2134         }
 
  2138         }
 
  2135 
  2139 
  2136     if ( iLocationRecord )
 
  2140     // Location record does not need to be loaded
 
  2137         {
 
  2141     aClientPluginInstance->iGenRecordArray.AppendL( NULL );
 
  2138         CCDLocationRecord* locationRecord =
 
       
  2139                 static_cast<CCDLocationRecord*>( CCDRecordBase::CreateCopyRecordL( *iLocationRecord ) );
 
       
  2140         CleanupStack::PushL( locationRecord );
 
       
  2141         locationRecord->SetElementId( iLocationRecord->ElementId() );
 
       
  2142         aClientPluginInstance->iGenRecordArray.AppendL( static_cast<CommsDat::CCDRecordBase*>( locationRecord ) );
 
       
  2143         CleanupStack::Pop( locationRecord );
 
       
  2144         }
 
       
  2145     else
 
       
  2146         {
 
       
  2147         aClientPluginInstance->iGenRecordArray.AppendL( NULL );
 
       
  2148         }
 
       
  2149 
  2142 
  2150     if ( iProxyRecord )
 
  2143     if ( iProxyRecord )
 
  2151         {
 
  2144         {
 
  2152         CCDProxiesRecord* proxyRecord =
 
  2145         CCDProxiesRecord* proxyRecord = static_cast<CCDProxiesRecord*>(
 
  2153                 static_cast<CCDProxiesRecord*>( CCDRecordBase::CreateCopyRecordL( *iProxyRecord ) );
 
  2146                 CCDRecordBase::CreateCopyRecordL( *iProxyRecord ) );
 
       
  2147         proxyRecord->SetElementId( iProxyRecord->ElementId() );
 
  2154         CleanupStack::PushL( proxyRecord );
 
  2148         CleanupStack::PushL( proxyRecord );
 
  2155         proxyRecord->SetElementId( iProxyRecord->ElementId() );
 
  2149         aClientPluginInstance->iGenRecordArray.AppendL(
 
  2156         aClientPluginInstance->iGenRecordArray.AppendL( static_cast<CommsDat::CCDRecordBase*>( proxyRecord ) );
 
  2150                 static_cast<CommsDat::CCDRecordBase*>( proxyRecord ) );
 
  2157         CleanupStack::Pop( proxyRecord );
 
  2151         CleanupStack::Pop( proxyRecord );
 
  2158         }
 
  2152         }
 
  2159     else
 
  2153     else
 
  2160         {
 
  2154         {
 
  2161         aClientPluginInstance->iGenRecordArray.AppendL( NULL );
 
  2155         aClientPluginInstance->iGenRecordArray.AppendL( NULL );
 
  2328                     aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] )->iUseProxyServer;
 
  2322                     aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] )->iUseProxyServer;
 
  2329             }
 
  2323             }
 
  2330             break;
 
  2324             break;
 
  2331         case ECmDestination:
 
  2325         case ECmDestination:
 
  2332             {
 
  2326             {
 
  2333             TRAPD( err, retVal = GetBearerBoolAttributeL( aAttribute,
 
  2327             TRAPD( err, retVal = GetBearerBoolAttributeL(
 
  2334                                                           aClientPluginInstance->iGenRecordArray,
 
  2328                     aAttribute,
 
  2335                                                           aClientPluginInstance->iBearerSpecRecordArray ) );
 
  2329                     aClientPluginInstance->iGenRecordArray,
 
       
  2330                     aClientPluginInstance->iBearerSpecRecordArray ) );
 
  2336             if ( err )
 
  2331             if ( err )
 
  2337                 {
 
  2332                 {
 
  2338                 if ( err == KErrNotFound )
 
  2333                 if ( err == KErrNotFound )
 
  2339                     {
 
  2334                     {
 
  2340                     retVal = EFalse;
 
  2335                     retVal = EFalse;
 
  2349         case ECmChargeCardUsageEnabled:
 
  2344         case ECmChargeCardUsageEnabled:
 
  2350             {
 
  2345             {
 
  2351             retVal = EFalse;
 
  2346             retVal = EFalse;
 
  2352             }
 
  2347             }
 
  2353             break;
 
  2348             break;
 
       
  2349         case ECmLocationUsageEnabled:
 
       
  2350             {
 
       
  2351             retVal = iLocationEnabled;
 
       
  2352             }
 
       
  2353             break;
 
  2354         case ECmCoverage:
 
  2354         case ECmCoverage:
 
  2355             // By default the plugin has no network coverage.
 
  2355             // By default the plugin has no network coverage.
 
  2356             {
 
  2356             {
 
  2357             TRAPD( err, retVal = GetBearerBoolAttributeL( aAttribute,
 
  2357             TRAPD( err, retVal = GetBearerBoolAttributeL(
 
  2358                                                           aClientPluginInstance->iGenRecordArray,
 
  2358                     aAttribute,
 
  2359                                                           aClientPluginInstance->iBearerSpecRecordArray ) );
 
  2359                     aClientPluginInstance->iGenRecordArray,
 
       
  2360                     aClientPluginInstance->iBearerSpecRecordArray ) );
 
  2360             if ( err )
 
  2361             if ( err )
 
  2361                 {
 
  2362                 {
 
  2362                 if ( err == KErrNotFound )
 
  2363                 if ( err == KErrNotFound )
 
  2363                     {
 
  2364                     {
 
  2364                     retVal = EFalse;
 
  2365                     retVal = EFalse;
 
  2370                 }
 
  2371                 }
 
  2371             }
 
  2372             }
 
  2372             break;
 
  2373             break;
 
  2373         case ECmMetaHighlight:
 
  2374         case ECmMetaHighlight:
 
  2374             {
 
  2375             {
 
  2375             CCDIAPMetadataRecord* metadataRecord =
 
  2376             CCDIAPMetadataRecord* metadataRecord = static_cast<CCDIAPMetadataRecord*>(
 
  2376                 static_cast<CCDIAPMetadataRecord*>(
 
       
  2377                     aClientPluginInstance->iGenRecordArray[KMetaDataRecordIndex] );
 
  2377                     aClientPluginInstance->iGenRecordArray[KMetaDataRecordIndex] );
 
  2378             retVal = metadataRecord->iMetadata & EMetaHighlight;
 
  2378             retVal = metadataRecord->iMetadata & EMetaHighlight;
 
  2379             }
 
  2379             }
 
  2380             break;
 
  2380             break;
 
  2381         case ECmMetaHiddenAgent:
 
  2381         case ECmMetaHiddenAgent:
 
  2382             {
 
  2382             {
 
  2383             CCDIAPMetadataRecord* metadataRecord =
 
  2383             CCDIAPMetadataRecord* metadataRecord = static_cast<CCDIAPMetadataRecord*>(
 
  2384                 static_cast<CCDIAPMetadataRecord*>(
 
       
  2385                     aClientPluginInstance->iGenRecordArray[KMetaDataRecordIndex] );
 
  2384                     aClientPluginInstance->iGenRecordArray[KMetaDataRecordIndex] );
 
  2386             retVal = metadataRecord->iMetadata & EMetaHiddenAgent;
 
  2385             retVal = metadataRecord->iMetadata & EMetaHiddenAgent;
 
  2387             }
 
  2386             }
 
  2388             break;
 
  2387             break;
 
  2389         case ECmVirtual:
 
  2388         case ECmVirtual:
 
  2418         TUint32 aAttribute,
 
  2417         TUint32 aAttribute,
 
  2419         CCmClientPluginInstance* aClientPluginInstance )
 
  2418         CCmClientPluginInstance* aClientPluginInstance )
 
  2420     {
 
  2419     {
 
  2421     OstTraceFunctionEntry0( CCMPLUGINBASEENG_GETSTRINGATTRIBUTEL_ENTRY );
 
  2420     OstTraceFunctionEntry0( CCMPLUGINBASEENG_GETSTRINGATTRIBUTEL_ENTRY );
 
  2422 
  2421 
       
  2422     if ( !aClientPluginInstance )
 
       
  2423         {
 
       
  2424         User::Leave( KErrCorrupt );
 
       
  2425         }
 
       
  2426 
  2423     HBufC* retVal = NULL;
 
  2427     HBufC* retVal = NULL;
 
  2424 
  2428 
  2425     switch ( aAttribute )
 
  2429     switch ( aAttribute )
 
  2426         {
 
  2430         {
 
       
  2431         case ECmBearerIcon:
 
       
  2432             {
 
       
  2433             //TODO, read icon name from metadata record after commsdat changes implemented.
 
       
  2434             //CCDIAPMetadataRecord* metadataRecord = static_cast<CCDIAPMetadataRecord*>(
 
       
  2435             //        aClientPluginInstance->iGenRecordArray[KMetaDataRecordIndex] );
 
       
  2436 
       
  2437             //if ( !metadataRecord )
 
       
  2438             //    {
 
       
  2439             //    User::Leave( KErrCorrupt );
 
       
  2440             //    }
 
       
  2441 
       
  2442             //retVal = TPtrC( metadataRecord->iIconFileName ).AllocL();
 
       
  2443             retVal = KNullDesC().AllocL();//TODO, check this freed
 
       
  2444             }
 
       
  2445             break;
 
  2427         case ECmStartPage:
 
  2446         case ECmStartPage:
 
  2428             {
 
  2447             {
 
  2429             CCDWAPAccessPointRecord* wapAPRecord =
 
  2448             CCDWAPAccessPointRecord* wapAPRecord = static_cast<CCDWAPAccessPointRecord*>(
 
  2430                 static_cast<CCDWAPAccessPointRecord*>(
 
       
  2431                     aClientPluginInstance->iGenRecordArray[KWAPAPRecordIndex] );
 
  2449                     aClientPluginInstance->iGenRecordArray[KWAPAPRecordIndex] );
 
       
  2450 
       
  2451             if ( !wapAPRecord )
 
       
  2452                 {
 
       
  2453                 User::Leave( KErrCorrupt );
 
       
  2454                 }
 
  2432 
  2455 
  2433             retVal = TPtrC( wapAPRecord->iWAPStartPage ).AllocL();
 
  2456             retVal = TPtrC( wapAPRecord->iWAPStartPage ).AllocL();
 
  2434             }
 
  2457             }
 
  2435             break;
 
  2458             break;
 
  2436         case ECmName:
 
  2459         case ECmName:
 
  2437             {
 
  2460             {
 
  2438             CCDIAPRecord* iapRecord = static_cast<CCDIAPRecord*>(
 
  2461             CCDIAPRecord* iapRecord = static_cast<CCDIAPRecord*>(
 
  2439                     aClientPluginInstance->iGenRecordArray[KIapRecordIndex] );
 
  2462                     aClientPluginInstance->iGenRecordArray[KIapRecordIndex] );
 
  2440 
  2463 
       
  2464             if ( !iapRecord )
 
       
  2465                 {
 
       
  2466                 User::Leave( KErrCorrupt );
 
       
  2467                 }
 
       
  2468 
  2441             retVal = TPtrC( iapRecord->iRecordName ).AllocL();
 
  2469             retVal = TPtrC( iapRecord->iRecordName ).AllocL();
 
  2442             }
 
  2470             }
 
  2443             break;
 
  2471             break;
 
  2444         case ECmProxyServerName:
 
  2472         case ECmProxyServerName:
 
  2445             {
 
  2473             {
 
  2446             if ( !aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] )
 
       
  2447                 {
 
       
  2448                 User::Leave( KErrNotFound );
 
       
  2449                 }
 
       
  2450 
       
  2451             CCDProxiesRecord* proxyRecord = static_cast<CCDProxiesRecord*>(
 
  2474             CCDProxiesRecord* proxyRecord = static_cast<CCDProxiesRecord*>(
 
  2452                     aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] );
 
  2475                     aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] );
 
  2453 
  2476 
       
  2477             if ( !proxyRecord )
 
       
  2478                 {
 
       
  2479                 User::Leave( KErrCorrupt );
 
       
  2480                 }
 
       
  2481 
  2454             retVal = TPtrC( proxyRecord->iServerName ).AllocL();
 
  2482             retVal = TPtrC( proxyRecord->iServerName ).AllocL();
 
  2455             }
 
  2483             }
 
  2456             break;
 
  2484             break;
 
  2457         case ECmProxyProtocolName:
 
  2485         case ECmProxyProtocolName:
 
  2458             {
 
  2486             {
 
  2459             if ( !aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] )
 
       
  2460                 {
 
       
  2461                 User::Leave( KErrNotFound );
 
       
  2462                 }
 
       
  2463 
       
  2464             CCDProxiesRecord* proxyRecord = static_cast<CCDProxiesRecord*>(
 
  2487             CCDProxiesRecord* proxyRecord = static_cast<CCDProxiesRecord*>(
 
  2465                     aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] );
 
  2488                     aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] );
 
  2466 
  2489 
       
  2490             if ( !proxyRecord )
 
       
  2491                 {
 
       
  2492                 User::Leave( KErrCorrupt );
 
       
  2493                 }
 
       
  2494 
  2467             retVal = TPtrC( proxyRecord->iExceptions ).AllocL();
 
  2495             retVal = TPtrC( proxyRecord->iExceptions ).AllocL();
 
  2468             }
 
  2496             }
 
  2469             break;
 
  2497             break;
 
  2470         case ECmProxyExceptions:
 
  2498         case ECmProxyExceptions:
 
  2471             {
 
  2499             {
 
  2472             if ( !aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] )
 
       
  2473                 {
 
       
  2474                 User::Leave( KErrNotFound );
 
       
  2475                 }
 
       
  2476 
       
  2477             CCDProxiesRecord* proxyRecord = static_cast<CCDProxiesRecord*>(
 
  2500             CCDProxiesRecord* proxyRecord = static_cast<CCDProxiesRecord*>(
 
  2478                     aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] );
 
  2501                     aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] );
 
  2479 
  2502 
       
  2503             if ( !proxyRecord )
 
       
  2504                 {
 
       
  2505                 User::Leave( KErrCorrupt );
 
       
  2506                 }
 
       
  2507 
  2480             retVal = TPtrC( proxyRecord->iProtocolName ).AllocL();
 
  2508             retVal = TPtrC( proxyRecord->iProtocolName ).AllocL();
 
  2481             }
 
  2509             }
 
  2482             break;
 
  2510             break;
 
  2483         case ECmWapIPGatewayAddress:
 
  2511         case ECmWapIPGatewayAddress:
 
  2484             {
 
  2512             {
 
  2485             if ( !aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] )
 
       
  2486                 {
 
       
  2487                 User::Leave( KErrNotFound );
 
       
  2488                 }
 
       
  2489 
       
  2490             CCDWAPIPBearerRecord* wapIPBearerRecord = static_cast<CCDWAPIPBearerRecord*>(
 
  2513             CCDWAPIPBearerRecord* wapIPBearerRecord = static_cast<CCDWAPIPBearerRecord*>(
 
  2491                     aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] );
 
  2514                     aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] );
 
  2492 
  2515 
       
  2516             if ( !wapIPBearerRecord )
 
       
  2517                 {
 
       
  2518                 User::Leave( KErrCorrupt );
 
       
  2519                 }
 
       
  2520 
  2493             retVal = TPtrC( wapIPBearerRecord->iWAPGatewayAddress ).AllocL();
 
  2521             retVal = TPtrC( wapIPBearerRecord->iWAPGatewayAddress ).AllocL();
 
  2494             }
 
  2522             }
 
  2495             break;
 
  2523             break;
 
  2496         case ECmWapIPProxyLoginName:
 
  2524         case ECmWapIPProxyLoginName:
 
  2497             {
 
  2525             {
 
  2498             if ( !aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] )
 
       
  2499                 {
 
       
  2500                 User::Leave( KErrNotFound );
 
       
  2501                 }
 
       
  2502 
       
  2503             CCDWAPIPBearerRecord* wapIPBearerRecord = static_cast<CCDWAPIPBearerRecord*>(
 
  2526             CCDWAPIPBearerRecord* wapIPBearerRecord = static_cast<CCDWAPIPBearerRecord*>(
 
  2504                     aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] );
 
  2527                     aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] );
 
  2505 
  2528 
       
  2529             if ( !wapIPBearerRecord )
 
       
  2530                 {
 
       
  2531                 User::Leave( KErrCorrupt );
 
       
  2532                 }
 
       
  2533 
  2506             retVal = TPtrC( wapIPBearerRecord->iWAPProxyLoginName ).AllocL();
 
  2534             retVal = TPtrC( wapIPBearerRecord->iWAPProxyLoginName ).AllocL();
 
  2507             }
 
  2535             }
 
  2508             break;
 
  2536             break;
 
  2509         case ECmWapIPProxyLoginPass:
 
  2537         case ECmWapIPProxyLoginPass:
 
  2510             {
 
  2538             {
 
  2511             if ( !aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] )
 
       
  2512                 {
 
       
  2513                 User::Leave( KErrNotFound );
 
       
  2514                 }
 
       
  2515 
       
  2516             CCDWAPIPBearerRecord* wapIPBearerRecord = static_cast<CCDWAPIPBearerRecord*>(
 
  2539             CCDWAPIPBearerRecord* wapIPBearerRecord = static_cast<CCDWAPIPBearerRecord*>(
 
  2517                     aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] );
 
  2540                     aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] );
 
       
  2541 
       
  2542             if ( !wapIPBearerRecord )
 
       
  2543                 {
 
       
  2544                 User::Leave( KErrCorrupt );
 
       
  2545                 }
 
  2518 
  2546 
  2519             retVal = TPtrC( wapIPBearerRecord->iWAPProxyLoginPass ).AllocL();
 
  2547             retVal = TPtrC( wapIPBearerRecord->iWAPProxyLoginPass ).AllocL();
 
  2520             }
 
  2548             }
 
  2521             break;
 
  2549             break;
 
  2522         default:
 
  2550         default:
 
  2558 
  2586 
  2559     OstTraceFunctionExit0( CCMPLUGINBASEENG_GETSTRING8ATTRIBUTEL_EXIT );
 
  2587     OstTraceFunctionExit0( CCMPLUGINBASEENG_GETSTRING8ATTRIBUTEL_EXIT );
 
  2560     return retVal;
 
  2588     return retVal;
 
  2561     }
 
  2589     }
 
  2562 
  2590 
  2563 //-----------------------------------------------------------------------------
 
  2591 // -----------------------------------------------------------------------------
 
  2564 // CCmPluginBaseEng::GetIntAttributeL
 
  2592 // CCmPluginBaseEng::GetIntAttributeL
 
  2565 // -----------------------------------------------------------------------------
 
  2593 // -----------------------------------------------------------------------------
 
  2566 EXPORT_C void CCmPluginBaseEng::SetIntAttributeL(
 
  2594 EXPORT_C void CCmPluginBaseEng::SetIntAttributeL(
 
  2567     TUint32 aAttribute,
 
  2595         TUint32 aAttribute,
 
  2568     TUint32 aValue,
 
  2596         TUint32 aValue,
 
  2569     CCmClientPluginInstance* aClientPluginInstance )
 
  2597         CCmClientPluginInstance* aClientPluginInstance )
 
  2570     {
 
  2598     {
 
  2571     OstTraceFunctionEntry0( CCMPLUGINBASEENG_SETINTATTRIBUTEL_ENTRY );
 
  2599     OstTraceFunctionEntry0( CCMPLUGINBASEENG_SETINTATTRIBUTEL_ENTRY );
 
  2572 
  2600 
  2573     switch ( aAttribute )
 
  2601     switch ( aAttribute )
 
  2574         {
 
  2602         {
 
  2591             {
 
  2619             {
 
  2592             if ( aValue == ESeamlessnessConfirmFirst || aValue == ESeamlessnessShowprogress )
 
  2620             if ( aValue == ESeamlessnessConfirmFirst || aValue == ESeamlessnessShowprogress )
 
  2593                 {
 
  2621                 {
 
  2594                 static_cast<CCDIAPMetadataRecord*>(
 
  2622                 static_cast<CCDIAPMetadataRecord*>(
 
  2595                         aClientPluginInstance->iGenRecordArray[KMetaDataRecordIndex] )->
 
  2623                         aClientPluginInstance->iGenRecordArray[KMetaDataRecordIndex] )->
 
  2596                                 iSeamlessness.SetL( aValue );
 
  2624                         iSeamlessness.SetL( aValue );
 
  2597                 }
 
  2625                 }
 
  2598             else
 
  2626             else
 
  2599                 {
 
  2627                 {
 
  2600                 User::Leave( KErrNotSupported );
 
  2628                 User::Leave( KErrNotSupported );
 
  2601                 }
 
  2629                 }
 
  2609             break;
 
  2637             break;
 
  2610         case ECmProxyPortNumber:
 
  2638         case ECmProxyPortNumber:
 
  2611             {
 
  2639             {
 
  2612             if ( !aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] )
 
  2640             if ( !aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] )
 
  2613                 {
 
  2641                 {
 
  2614                 CCDProxiesRecord* proxyRecord =
 
  2642                 CCDProxiesRecord* proxyRecord = static_cast<CCDProxiesRecord*>(
 
  2615                         static_cast<CCDProxiesRecord*>( CCDRecordBase::CreateCopyRecordL( *iProxyRecord ) );
 
  2643                         CCDRecordBase::CreateCopyRecordL( *iProxyRecord ) );
 
  2616                 CleanupStack::PushL( proxyRecord );
 
  2644                 CleanupStack::PushL( proxyRecord );
 
  2617                 proxyRecord->SetElementId( iProxyRecord->ElementId() );
 
  2645                 proxyRecord->SetElementId( iProxyRecord->ElementId() );
 
  2618                 aClientPluginInstance->iGenRecordArray.AppendL( static_cast<CommsDat::CCDRecordBase*>( proxyRecord ) );
 
  2646                 aClientPluginInstance->iGenRecordArray.AppendL(
 
       
  2647                         static_cast<CommsDat::CCDRecordBase*>( proxyRecord ) );
 
  2619                 CleanupStack::Pop( proxyRecord );
 
  2648                 CleanupStack::Pop( proxyRecord );
 
  2620                 }
 
  2649                 }
 
  2621 
  2650 
  2622             static_cast<CCDProxiesRecord*>(
 
  2651             static_cast<CCDProxiesRecord*>(
 
  2623                     aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] )
 
  2652                     aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] )->
 
  2624                         ->iPortNumber = aValue;
 
  2653                     iPortNumber = aValue;
 
  2625             }
 
  2654             }
 
  2626             break;
 
  2655             break;
 
  2627         case ECmWapIPWSPOption:
 
  2656         case ECmWapIPWSPOption:
 
  2628             {
 
  2657             {
 
  2629             if ( aValue > KMaxTUint8 )
 
  2658             if ( aValue > KMaxTUint8 )
 
  2631                 User::Leave( KErrArgument );
 
  2660                 User::Leave( KErrArgument );
 
  2632                 }
 
  2661                 }
 
  2633             else
 
  2662             else
 
  2634                 {
 
  2663                 {
 
  2635                 static_cast<CCDWAPIPBearerRecord*>(
 
  2664                 static_cast<CCDWAPIPBearerRecord*>(
 
  2636                         aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] )->iWAPWSPOption.SetL( aValue );
 
  2665                         aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] )->
 
       
  2666                         iWAPWSPOption.SetL( aValue );
 
  2637                 }
 
  2667                 }
 
  2638             }
 
  2668             }
 
  2639             break;
 
  2669             break;
 
  2640         case ECmWapIPProxyPort:
 
  2670         case ECmWapIPProxyPort:
 
  2641             {
 
  2671             {
 
  2642             static_cast<CCDWAPIPBearerRecord*>(
 
  2672             static_cast<CCDWAPIPBearerRecord*>(
 
  2643                     aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] )->iWAPProxyPort.SetL( aValue );
 
  2673                     aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] )->
 
       
  2674                     iWAPProxyPort.SetL( aValue );
 
  2644             }
 
  2675             }
 
  2645             break;
 
  2676             break;
 
  2646         default:
 
  2677         default:
 
  2647             {
 
  2678             {
 
  2648             SetBearerIntAttributeL( aAttribute,
 
  2679             SetBearerIntAttributeL(
 
  2649                                     aValue,
 
  2680                     aAttribute,
 
  2650                                     aClientPluginInstance->iGenRecordArray,
 
  2681                     aValue,
 
  2651                                     aClientPluginInstance->iBearerSpecRecordArray );
 
  2682                     aClientPluginInstance->iGenRecordArray,
 
  2652             }
 
  2683                     aClientPluginInstance->iBearerSpecRecordArray );
 
  2653         }
 
  2684             }
 
       
  2685         }
 
       
  2686 
  2654     OstTraceFunctionExit0( CCMPLUGINBASEENG_SETINTATTRIBUTEL_EXIT );
 
  2687     OstTraceFunctionExit0( CCMPLUGINBASEENG_SETINTATTRIBUTEL_EXIT );
 
  2655     }
 
  2688     }
 
  2656 
  2689 
  2657 //-----------------------------------------------------------------------------
 
  2690 // -----------------------------------------------------------------------------
 
  2658 // CCmPluginBaseEng::SetBoolAttributeL
 
  2691 // CCmPluginBaseEng::SetBoolAttributeL
 
  2659 // -----------------------------------------------------------------------------
 
  2692 // -----------------------------------------------------------------------------
 
  2660 EXPORT_C void CCmPluginBaseEng::SetBoolAttributeL(
 
  2693 EXPORT_C void CCmPluginBaseEng::SetBoolAttributeL(
 
  2661     TUint32 aAttribute,
 
  2694         TUint32 aAttribute,
 
  2662     TBool aValue,
 
  2695         TBool aValue,
 
  2663     CCmClientPluginInstance* aClientPluginInstance )
 
  2696         CCmClientPluginInstance* aClientPluginInstance )
 
  2664     {
 
  2697     {
 
  2665     OstTraceFunctionEntry0( CCMPLUGINBASEENG_SETBOOLATTRIBUTEL_ENTRY );
 
  2698     OstTraceFunctionEntry0( CCMPLUGINBASEENG_SETBOOLATTRIBUTEL_ENTRY );
 
  2666 
  2699 
  2667     CCDIAPRecord* iapRecord = static_cast<CCDIAPRecord*>(
 
  2700     CCDIAPRecord* iapRecord = static_cast<CCDIAPRecord*>(
 
  2668                         aClientPluginInstance->iGenRecordArray[KIapRecordIndex] );
 
  2701             aClientPluginInstance->iGenRecordArray[KIapRecordIndex] );
 
  2669 
  2702 
  2670     switch ( aAttribute )
 
  2703     switch ( aAttribute )
 
  2671         {
 
  2704         {
 
  2672         case ECmProtected:
 
  2705         case ECmProtected:
 
  2673             {
 
  2706             {
 
  2705             break;
 
  2738             break;
 
  2706         case ECmProxyUsageEnabled:
 
  2739         case ECmProxyUsageEnabled:
 
  2707             {
 
  2740             {
 
  2708             if ( !aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] )
 
  2741             if ( !aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] )
 
  2709                 {
 
  2742                 {
 
  2710                 CCDProxiesRecord* proxyRecord =
 
  2743                 CCDProxiesRecord* proxyRecord = static_cast<CCDProxiesRecord*>(
 
  2711                         static_cast<CCDProxiesRecord*>( CCDRecordBase::CreateCopyRecordL( *iProxyRecord ) );
 
  2744                         CCDRecordBase::CreateCopyRecordL( *iProxyRecord ) );
 
  2712                 CleanupStack::PushL( proxyRecord );
 
  2745                 CleanupStack::PushL( proxyRecord );
 
  2713                 proxyRecord->SetElementId( iProxyRecord->ElementId() );
 
  2746                 proxyRecord->SetElementId( iProxyRecord->ElementId() );
 
  2714                 aClientPluginInstance->iGenRecordArray.AppendL( static_cast<CommsDat::CCDRecordBase*>( proxyRecord ) );
 
  2747                 aClientPluginInstance->iGenRecordArray.AppendL(
 
       
  2748                         static_cast<CommsDat::CCDRecordBase*>( proxyRecord ) );
 
  2715                 CleanupStack::Pop( proxyRecord );
 
  2749                 CleanupStack::Pop( proxyRecord );
 
  2716                 }
 
  2750                 }
 
  2717 
  2751 
  2718             static_cast<CCDProxiesRecord*>(
 
  2752             static_cast<CCDProxiesRecord*>(
 
  2719                     aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] )
 
  2753                     aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] )->iUseProxyServer =
 
  2720                         ->iUseProxyServer = aValue;
 
  2754                             aValue;
 
  2721             }
 
  2755             }
 
  2722             break;
 
  2756             break;
 
  2723         case ECmChargeCardUsageEnabled:
 
  2757         case ECmChargeCardUsageEnabled:
 
  2724             {
 
  2758             {
 
  2725             User::Leave( KErrNotSupported );
 
  2759             User::Leave( KErrNotSupported );
 
  2729             {
 
  2763             {
 
  2730             EnableLocationL( aValue );
 
  2764             EnableLocationL( aValue );
 
  2731             }
 
  2765             }
 
  2732             break;
 
  2766             break;
 
  2733         case ECmMetaHighlight:
 
  2767         case ECmMetaHighlight:
 
  2734             {
 
       
  2735             CCDIAPMetadataRecord* metadataRecord =
 
       
  2736                 static_cast<CCDIAPMetadataRecord*>(
 
       
  2737                         aClientPluginInstance->iGenRecordArray[KMetaDataRecordIndex] );
 
       
  2738             if ( aValue )
 
       
  2739                 {
 
       
  2740                 metadataRecord->iMetadata = EMetaHighlight | metadataRecord->iMetadata;
 
       
  2741                 }
 
       
  2742             else
 
       
  2743                 {
 
       
  2744                 metadataRecord->iMetadata = ~EMetaHighlight & metadataRecord->iMetadata;
 
       
  2745                 }
 
       
  2746             }
 
       
  2747             break;
 
       
  2748         case ECmMetaHiddenAgent:
 
       
  2749             {
 
  2768             {
 
  2750             CCDIAPMetadataRecord* metadataRecord = static_cast<CCDIAPMetadataRecord*>(
 
  2769             CCDIAPMetadataRecord* metadataRecord = static_cast<CCDIAPMetadataRecord*>(
 
  2751                     aClientPluginInstance->iGenRecordArray[KMetaDataRecordIndex] );
 
  2770                     aClientPluginInstance->iGenRecordArray[KMetaDataRecordIndex] );
 
  2752             if ( aValue )
 
  2771             if ( aValue )
 
  2753                 {
 
  2772                 {
 
       
  2773                 metadataRecord->iMetadata = EMetaHighlight | metadataRecord->iMetadata;
 
       
  2774                 }
 
       
  2775             else
 
       
  2776                 {
 
       
  2777                 metadataRecord->iMetadata = ~EMetaHighlight & metadataRecord->iMetadata;
 
       
  2778                 }
 
       
  2779             }
 
       
  2780             break;
 
       
  2781         case ECmMetaHiddenAgent:
 
       
  2782             {
 
       
  2783             CCDIAPMetadataRecord* metadataRecord = static_cast<CCDIAPMetadataRecord*>(
 
       
  2784                     aClientPluginInstance->iGenRecordArray[KMetaDataRecordIndex] );
 
       
  2785             if ( aValue )
 
       
  2786                 {
 
  2754                 metadataRecord->iMetadata = EMetaHiddenAgent | metadataRecord->iMetadata;
 
  2787                 metadataRecord->iMetadata = EMetaHiddenAgent | metadataRecord->iMetadata;
 
  2755                 }
 
  2788                 }
 
  2756             else
 
  2789             else
 
  2757                 {
 
  2790                 {
 
  2758                 metadataRecord->iMetadata = ~EMetaHiddenAgent & metadataRecord->iMetadata;
 
  2791                 metadataRecord->iMetadata = ~EMetaHiddenAgent & metadataRecord->iMetadata;
 
  2760             }
 
  2793             }
 
  2761             break;
 
  2794             break;
 
  2762         case ECmWapIPSecurity:
 
  2795         case ECmWapIPSecurity:
 
  2763             {
 
  2796             {
 
  2764             static_cast<CCDWAPIPBearerRecord*>(
 
  2797             static_cast<CCDWAPIPBearerRecord*>(
 
  2765                     aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] )->iWAPSecurity.SetL( aValue );
 
  2798                     aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] )
 
       
  2799                     ->iWAPSecurity.SetL( aValue );
 
  2766             }
 
  2800             }
 
  2767             break;
 
  2801             break;
 
  2768         default:
 
  2802         default:
 
  2769             {
 
  2803             {
 
  2770             SetBearerBoolAttributeL( aAttribute,
 
  2804             SetBearerBoolAttributeL(
 
  2771                                      aValue,
 
  2805                     aAttribute,
 
  2772                                      aClientPluginInstance->iGenRecordArray,
 
  2806                     aValue,
 
  2773                                      aClientPluginInstance->iBearerSpecRecordArray );
 
  2807                     aClientPluginInstance->iGenRecordArray,
 
  2774             }
 
  2808                     aClientPluginInstance->iBearerSpecRecordArray );
 
  2775         }
 
  2809             }
 
       
  2810         }
 
       
  2811 
  2776     OstTraceFunctionExit0( CCMPLUGINBASEENG_SETBOOLATTRIBUTEL_EXIT );
 
  2812     OstTraceFunctionExit0( CCMPLUGINBASEENG_SETBOOLATTRIBUTEL_EXIT );
 
  2777     }
 
  2813     }
 
  2778 
  2814 
  2779 //-----------------------------------------------------------------------------
 
  2815 // -----------------------------------------------------------------------------
 
  2780 // CCmPluginBaseEng::SetStringAttributeL
 
  2816 // CCmPluginBaseEng::SetStringAttributeL
 
  2781 // -----------------------------------------------------------------------------
 
  2817 // -----------------------------------------------------------------------------
 
  2782 EXPORT_C void CCmPluginBaseEng::SetStringAttributeL(
 
  2818 EXPORT_C void CCmPluginBaseEng::SetStringAttributeL(
 
  2783     TUint32 aAttribute,
 
  2819         TUint32 aAttribute,
 
  2784     const TDesC16& aValue,
 
  2820         const TDesC16& aValue,
 
  2785     CCmClientPluginInstance* aClientPluginInstance )
 
  2821         CCmClientPluginInstance* aClientPluginInstance )
 
  2786     {
 
  2822     {
 
  2787     OstTraceFunctionEntry0( CCMPLUGINBASEENG_SETSTRINGATTRIBUTEL_ENTRY );
 
  2823     OstTraceFunctionEntry0( CCMPLUGINBASEENG_SETSTRINGATTRIBUTEL_ENTRY );
 
  2788 
  2824 
  2789     switch ( aAttribute )
 
  2825     switch ( aAttribute )
 
  2790         {
 
  2826         {
 
       
  2827         case ECmBearerIcon:
 
       
  2828             {
 
       
  2829             //TODO, write icon name to metadata record after commsdat changes implemented.
 
       
  2830             //CCDIAPMetadataRecord* metadataRecord = static_cast<CCDIAPMetadataRecord*>(
 
       
  2831             //        aClientPluginInstance->iGenRecordArray[KMetaDataRecordIndex] );
 
       
  2832 
       
  2833             //if ( !metadataRecord )
 
       
  2834             //    {
 
       
  2835             //    User::Leave( KErrCorrupt );
 
       
  2836             //    }
 
       
  2837             //metadataRecord->iIconFileName.SetL( aValue );
 
       
  2838             }
 
       
  2839             break;
 
  2791         case ECmStartPage:
 
  2840         case ECmStartPage:
 
  2792             {
 
  2841             {
 
  2793             CCDWAPAccessPointRecord* wapAPRecord =
 
  2842             CCDWAPAccessPointRecord* wapAPRecord = static_cast<CCDWAPAccessPointRecord*>(
 
  2794                 static_cast<CCDWAPAccessPointRecord*>(
 
  2843                     aClientPluginInstance->iGenRecordArray[KWAPAPRecordIndex] );
 
  2795                         aClientPluginInstance->iGenRecordArray[KWAPAPRecordIndex] );
 
  2844 
  2796 
  2845             if ( !wapAPRecord )
 
       
  2846                 {
 
       
  2847                 User::Leave( KErrCorrupt );
 
       
  2848                 }
 
  2797             wapAPRecord->iWAPStartPage.SetL( aValue );
 
  2849             wapAPRecord->iWAPStartPage.SetL( aValue );
 
  2798             }
 
  2850             }
 
  2799             break;
 
  2851             break;
 
  2800         case ECmName:
 
  2852         case ECmName:
 
  2801             {
 
  2853             {
 
  2802             CCDIAPRecord* iapRecord = static_cast<CCDIAPRecord*>(
 
  2854             CCDIAPRecord* iapRecord = static_cast<CCDIAPRecord*>(
 
  2803                     aClientPluginInstance->iGenRecordArray[KIapRecordIndex] );
 
  2855                     aClientPluginInstance->iGenRecordArray[KIapRecordIndex] );
 
  2804 
  2856 
       
  2857             if ( !iapRecord )
 
       
  2858                 {
 
       
  2859                 User::Leave( KErrCorrupt );
 
       
  2860                 }
 
  2805             SetNameL( aValue, iapRecord, aClientPluginInstance->iNamingMethod );
 
  2861             SetNameL( aValue, iapRecord, aClientPluginInstance->iNamingMethod );
 
  2806             }
 
  2862             }
 
  2807             break;
 
  2863             break;
 
  2808         case ECmProxyServerName:
 
  2864         case ECmProxyServerName:
 
  2809             {
 
  2865             {
 
  2810             CCDProxiesRecord* proxyRecord =
 
  2866             CCDProxiesRecord* proxyRecord = static_cast<CCDProxiesRecord*>(
 
  2811                     static_cast<CCDProxiesRecord*>(
 
  2867                     aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] );
 
  2812                             aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] );
 
       
  2813             if ( !proxyRecord )
 
  2868             if ( !proxyRecord )
 
  2814                 {
 
  2869                 {
 
  2815                 proxyRecord = static_cast<CCDProxiesRecord *>
 
  2870                 proxyRecord = static_cast<CCDProxiesRecord*>(
 
  2816                               ( CCDRecordBase::RecordFactoryL(KCDTIdProxiesRecord ) );
 
  2871                         CCDRecordBase::RecordFactoryL( KCDTIdProxiesRecord ) );
 
  2817 
  2872 
  2818                 // map proxy record to this iap.
 
  2873                 // Map proxy record to this iap.
 
  2819                 proxyRecord->iService =
 
  2874                 proxyRecord->iService = static_cast<CCDProxiesRecord*>(
 
  2820                         static_cast<CCDProxiesRecord*>(
 
  2875                         aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] )->RecordId();
 
  2821                                 aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] )->RecordId();
 
       
  2822 
  2876 
  2823                 aClientPluginInstance->iGenRecordArray.Insert( proxyRecord, KProxyRecordIndex );
 
  2877                 aClientPluginInstance->iGenRecordArray.Insert( proxyRecord, KProxyRecordIndex );
 
  2824                 }
 
  2878                 }
 
  2825 
  2879 
  2826             SetProxyServerNameL( aValue, proxyRecord );
 
  2880             SetProxyServerNameL( aValue, proxyRecord );
 
  2827             }
 
  2881             }
 
  2828             break;
 
  2882             break;
 
  2829         case ECmProxyProtocolName:
 
  2883         case ECmProxyProtocolName:
 
  2830             {
 
  2884             {
 
  2831             CCDProxiesRecord* proxyRecord =
 
  2885             CCDProxiesRecord* proxyRecord = static_cast<CCDProxiesRecord*>(
 
  2832                     static_cast<CCDProxiesRecord*>(
 
  2886                     aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] );
 
  2833                             aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] );
 
       
  2834             if ( !proxyRecord )
 
  2887             if ( !proxyRecord )
 
  2835                 {
 
  2888                 {
 
  2836                 proxyRecord = static_cast<CCDProxiesRecord *>
 
  2889                 proxyRecord = static_cast<CCDProxiesRecord*>(
 
  2837                               ( CCDRecordBase::RecordFactoryL(KCDTIdProxiesRecord ) );
 
  2890                         CCDRecordBase::RecordFactoryL( KCDTIdProxiesRecord ) );
 
  2838 
  2891 
  2839                 // map proxy record to this iap.
 
  2892                 // Map proxy record to this iap.
 
  2840                 proxyRecord->iService =
 
  2893                 proxyRecord->iService = static_cast<CCDProxiesRecord*>(
 
  2841                         static_cast<CCDProxiesRecord*>(
 
  2894                         aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] )->RecordId();
 
  2842                                 aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] )->RecordId();
 
       
  2843 
  2895 
  2844                 aClientPluginInstance->iGenRecordArray.Insert( proxyRecord, KProxyRecordIndex );
 
  2896                 aClientPluginInstance->iGenRecordArray.Insert( proxyRecord, KProxyRecordIndex );
 
  2845                 }
 
  2897                 }
 
  2846 
  2898 
  2847             proxyRecord->iProtocolName.SetL( aValue );
 
  2899             proxyRecord->iProtocolName.SetL( aValue );
 
  2848             }
 
  2900             }
 
  2849             break;
 
  2901             break;
 
  2850         case ECmProxyExceptions:
 
  2902         case ECmProxyExceptions:
 
  2851             {
 
  2903             {
 
  2852             CCDProxiesRecord* proxyRecord =
 
  2904             CCDProxiesRecord* proxyRecord = static_cast<CCDProxiesRecord*>(
 
  2853                     static_cast<CCDProxiesRecord*>(
 
  2905                     aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] );
 
  2854                             aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] );
 
       
  2855             if ( !proxyRecord )
 
  2906             if ( !proxyRecord )
 
  2856                 {
 
  2907                 {
 
  2857                 proxyRecord = static_cast<CCDProxiesRecord *>
 
  2908                 proxyRecord = static_cast<CCDProxiesRecord*>(
 
  2858                               ( CCDRecordBase::RecordFactoryL(KCDTIdProxiesRecord ) );
 
  2909                         CCDRecordBase::RecordFactoryL( KCDTIdProxiesRecord ) );
 
  2859 
  2910 
  2860                 // map proxy record to this iap.
 
  2911                 // Map proxy record to this iap.
 
  2861                 proxyRecord->iService =
 
  2912                 proxyRecord->iService = static_cast<CCDProxiesRecord*>(
 
  2862                         static_cast<CCDProxiesRecord*>(
 
  2913                         aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] )->RecordId();
 
  2863                                 aClientPluginInstance->iGenRecordArray[KProxyRecordIndex] )->RecordId();
 
       
  2864 
  2914 
  2865                 aClientPluginInstance->iGenRecordArray.Insert( proxyRecord, KProxyRecordIndex );
 
  2915                 aClientPluginInstance->iGenRecordArray.Insert( proxyRecord, KProxyRecordIndex );
 
  2866                 }
 
  2916                 }
 
  2867 
  2917 
  2868             proxyRecord->iExceptions.SetL( aValue );
 
  2918             proxyRecord->iExceptions.SetL( aValue );
 
  2871         case ECmWapIPGatewayAddress:
 
  2921         case ECmWapIPGatewayAddress:
 
  2872             {
 
  2922             {
 
  2873             CCDWAPIPBearerRecord* wapIPBearerRecord = static_cast<CCDWAPIPBearerRecord*>(
 
  2923             CCDWAPIPBearerRecord* wapIPBearerRecord = static_cast<CCDWAPIPBearerRecord*>(
 
  2874                     aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] );
 
  2924                     aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] );
 
  2875 
  2925 
       
  2926             if ( !wapIPBearerRecord )
 
       
  2927                 {
 
       
  2928                 User::Leave( KErrCorrupt );
 
       
  2929                 }
 
  2876             wapIPBearerRecord->iWAPGatewayAddress.SetL( aValue );
 
  2930             wapIPBearerRecord->iWAPGatewayAddress.SetL( aValue );
 
  2877             }
 
  2931             }
 
  2878             break;
 
  2932             break;
 
  2879         case ECmWapIPProxyLoginName:
 
  2933         case ECmWapIPProxyLoginName:
 
  2880             {
 
  2934             {
 
  2881             CCDWAPIPBearerRecord* wapIPBearerRecord = static_cast<CCDWAPIPBearerRecord*>(
 
  2935             CCDWAPIPBearerRecord* wapIPBearerRecord = static_cast<CCDWAPIPBearerRecord*>(
 
  2882                     aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] );
 
  2936                     aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] );
 
  2883 
  2937 
       
  2938             if ( !wapIPBearerRecord )
 
       
  2939                 {
 
       
  2940                 User::Leave( KErrCorrupt );
 
       
  2941                 }
 
  2884             wapIPBearerRecord->iWAPProxyLoginName.SetL( aValue );
 
  2942             wapIPBearerRecord->iWAPProxyLoginName.SetL( aValue );
 
  2885             }
 
  2943             }
 
  2886             break;
 
  2944             break;
 
  2887         case ECmWapIPProxyLoginPass:
 
  2945         case ECmWapIPProxyLoginPass:
 
  2888             {
 
  2946             {
 
  2889             CCDWAPIPBearerRecord* wapIPBearerRecord = static_cast<CCDWAPIPBearerRecord*>(
 
  2947             CCDWAPIPBearerRecord* wapIPBearerRecord = static_cast<CCDWAPIPBearerRecord*>(
 
  2890                     aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] );
 
  2948                     aClientPluginInstance->iGenRecordArray[KWAPBearerRecordIndex] );
 
  2891 
  2949 
       
  2950             if ( !wapIPBearerRecord )
 
       
  2951                 {
 
       
  2952                 User::Leave( KErrCorrupt );
 
       
  2953                 }
 
  2892             wapIPBearerRecord->iWAPProxyLoginPass.SetL( aValue );
 
  2954             wapIPBearerRecord->iWAPProxyLoginPass.SetL( aValue );
 
  2893             }
 
  2955             }
 
  2894             break;
 
  2956             break;
 
  2895         default:
 
  2957         default:
 
  2896             {
 
  2958             {
 
  2897             SetBearerStringAttributeL( aAttribute,
 
  2959             SetBearerStringAttributeL(
 
  2898                                        aValue,
 
  2960                     aAttribute,
 
  2899                                        aClientPluginInstance->iGenRecordArray,
 
  2961                     aValue,
 
  2900                                        aClientPluginInstance->iBearerSpecRecordArray );
 
  2962                     aClientPluginInstance->iGenRecordArray,
 
  2901             }
 
  2963                     aClientPluginInstance->iBearerSpecRecordArray );
 
  2902         }
 
  2964             }
 
       
  2965         }
 
       
  2966 
  2903     OstTraceFunctionExit0( CCMPLUGINBASEENG_SETSTRINGATTRIBUTEL_EXIT );
 
  2967     OstTraceFunctionExit0( CCMPLUGINBASEENG_SETSTRINGATTRIBUTEL_EXIT );
 
  2904     }
 
  2968     }
 
  2905 
  2969 
  2906 //-----------------------------------------------------------------------------
 
  2970 // -----------------------------------------------------------------------------
 
  2907 // CCmPluginBaseEng::SetString8AttributeL
 
  2971 // CCmPluginBaseEng::SetString8AttributeL
 
  2908 // -----------------------------------------------------------------------------
 
  2972 // -----------------------------------------------------------------------------
 
  2909 EXPORT_C void CCmPluginBaseEng::SetString8AttributeL(
 
  2973 EXPORT_C void CCmPluginBaseEng::SetString8AttributeL(
 
  2910     TUint32 aAttribute,
 
  2974         TUint32 aAttribute,
 
  2911     const TDesC8& aValue,
 
  2975         const TDesC8& aValue,
 
  2912     CCmClientPluginInstance* aClientPluginInstance )
 
  2976         CCmClientPluginInstance* aClientPluginInstance )
 
  2913     {
 
  2977     {
 
  2914     OstTraceFunctionEntry0( CCMPLUGINBASEENG_SETSTRING8ATTRIBUTEL_ENTRY );
 
  2978     OstTraceFunctionEntry0( CCMPLUGINBASEENG_SETSTRING8ATTRIBUTEL_ENTRY );
 
  2915 
  2979 
  2916     switch ( aAttribute )
 
  2980     switch ( aAttribute )
 
  2917         {
 
  2981         {
 
  2918         default:
 
  2982         default:
 
  2919             {
 
  2983             {
 
  2920             SetBearerString8AttributeL( aAttribute,
 
  2984             SetBearerString8AttributeL(
 
  2921                                         aValue,
 
  2985                     aAttribute,
 
  2922                                         aClientPluginInstance->iGenRecordArray,
 
  2986                     aValue,
 
  2923                                         aClientPluginInstance->iBearerSpecRecordArray );
 
  2987                     aClientPluginInstance->iGenRecordArray,
 
  2924             }
 
  2988                     aClientPluginInstance->iBearerSpecRecordArray );
 
  2925         }
 
  2989             }
 
       
  2990         }
 
       
  2991 
  2926     OstTraceFunctionExit0( CCMPLUGINBASEENG_SETSTRING8ATTRIBUTEL_EXIT );
 
  2992     OstTraceFunctionExit0( CCMPLUGINBASEENG_SETSTRING8ATTRIBUTEL_EXIT );
 
  2927     }
 
  2993     }
 
  2928 
  2994 
  2929 // ---------------------------------------------------------------------------
 
  2995 // ---------------------------------------------------------------------------
 
  2930 // CCmPluginBaseEng::IsUnspecifiedIPv4Address
 
  2996 // CCmPluginBaseEng::IsUnspecifiedIPv4Address
 
  2939         OstTraceFunctionExit0( _ISUNSPECIFIEDIPV4ADDRESS_EXIT );
 
  3005         OstTraceFunctionExit0( _ISUNSPECIFIEDIPV4ADDRESS_EXIT );
 
  2940         return ETrue;
 
  3006         return ETrue;
 
  2941         }
 
  3007         }
 
  2942 
  3008 
  2943     OstTraceFunctionExit0( DUP1__ISUNSPECIFIEDIPV4ADDRESS_EXIT );
 
  3009     OstTraceFunctionExit0( DUP1__ISUNSPECIFIEDIPV4ADDRESS_EXIT );
 
  2944 
       
  2945     return EFalse;
 
  3010     return EFalse;
 
  2946     }
 
  3011     }
 
  2947 
  3012 
  2948 // ---------------------------------------------------------------------------
 
  3013 // ---------------------------------------------------------------------------
 
  2949 // CCmPluginBaseEng::ClassifyIPv6Address
 
  3014 // CCmPluginBaseEng::ClassifyIPv6Address
 
  2966 
  3031 
  2967         return EIPv6WellKnown;
 
  3032         return EIPv6WellKnown;
 
  2968         }
 
  3033         }
 
  2969 
  3034 
  2970     OstTraceFunctionExit0( DUP2__CLASSIFYIPV6ADDRESS_EXIT );
 
  3035     OstTraceFunctionExit0( DUP2__CLASSIFYIPV6ADDRESS_EXIT );
 
  2971 
       
  2972     return EIPv6UserDefined;
 
  3036     return EIPv6UserDefined;
 
  2973     }
 
  3037     }
 
  2974 
  3038 
  2975 // End of file
 
  3039 // End of file
FCL/sf/mw/ipconnmgmt