diff -r 05bc53fe583b -r 83ca720e2b9a cmmanager/cmmgr/Framework/Src/ccmpluginbaseeng.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/cmmanager/cmmgr/Framework/Src/ccmpluginbaseeng.cpp Wed Sep 01 12:23:51 2010 +0100 @@ -0,0 +1,3531 @@ +/* +* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Implementation of plugin base class +* +*/ +#include +#include // RSocketServ, RConnection +#include // KAfInet +#include // TConnectionInfo +#include +#include +#include +#include + +#include +#include "cmmanagerimpl.h" +#include "cmdestinationimpl.h" +#include +#include +#include "cmlogger.h" +#include + +using namespace CMManager; +using namespace CommsDat; + +// EXTERNAL LINKS + +// MACROS + +#undef _IPV6_DISABLED + +// CONSTANTS +const TInt KApMaxConnNameLength = 30; +_LIT(KFormatPostfix, "%02d"); +_LIT(KFormatLargePostfix, "%d"); +_LIT(KFormatNameWithPostfix, "%S(%S)" ); +_LIT(KFormatNoPostfix, "%S"); +const TInt KMaxPostfixLength = 5; +const TInt KEstimatedOverhead = 8192; + +_LIT( KDefWapGatewayIpAddress, "0.0.0.0" ); + +_LIT( KLocationName, "Mobile" ); + +static const TCmAttribConvTable SIapConvTbl[] = + { + // iAttribId, iCommsDatId, iValidFuncL, + // iTitleId, + // iMaxLength, iAttribFlags, iDefValueResId, iEditorResId, iNotUsed1, iNotUsed2 + // first element describes the min-max values, does not connects to DB! + { ECmName, ECmIapId, NULL }, + { ECmName, KCDTIdRecordName, NULL, + R_CMMANAGERUI_CONNECTION_NAME, + KMaxConnNameLength, EConvNoZeroLength | EConvCompulsory, + 0, R_TEXT_SETTING_PAGE_CONN_NAME, NULL, NULL }, + { ECmIapId, KCDTIdRecordTag, NULL }, + { 0, 0, NULL }, + }; + +static const TCmAttribConvTable SProxyConvTbl[] = + { + // iAttribId, iCommsDatId, iValidFuncL, + // iTitleId, + // iMaxLength, iAttribFlags, iDefValueResId, iEditorResId, iNotUsed1, iNotUsed2 + { ECmProxyUsageEnabled, ECmProxyRangeMax, NULL }, + { ECmProxyUsageEnabled, KCDTIdUseProxyServer, NULL }, + { ECmProxyServerName, KCDTIdServerName, &SetProxyServerNameL, + R_QTN_SET_PROXY_SERVER_ADDRESS, + KMaxProxyServerLength, 0, R_QTN_SET_PROXY_SERVER_ADDRESS_NONE, R_TEXT_SETTING_PAGE_PROXY_SERVER_ADDR, NULL, NULL }, + { ECmProxyProtocolName, KCDTIdProtocolName, NULL }, + { ECmProxyPortNumber, KCDTIdPortNumber, &CheckPortNumberValidityL, + R_QTN_SET_PROXY_PORT_NUMBER, + KMaxProxyPortNumberLength, EConvNumber, 0, 0, NULL, NULL }, + { ECmProxyExceptions, KCDTIdExceptions, NULL }, + { 0, 0, NULL }, + }; + +static const TCmAttribConvTable SChargeCardConvTbl[] = + { + { ECmChargeCardUsageEnabled, ECmChargeCardRangeMax, NULL }, + { ECmChargeCardAccountNumber, KCDTIdAccountNo, NULL }, + { ECmChargeCardPIN, KCDTIdPin, NULL }, + { ECmChargeCardLocalRule, KCDTIdLocalRule, NULL }, + { ECmChargeCardNatRule, KCDTIdNatRule, NULL }, + { ECmChargeCardIntlRule, KCDTIdIntlRule, NULL }, + { 0, 0, NULL }, + }; + +static const TCmAttribConvTable SLocationConvTbl[] = + { + { ECmLocationUsageEnabled, ECmLocationRangeMax, NULL }, + { ECmLocationIntlPrefixCode, KCDTIdIntlPrefixCode, NULL }, + { ECmLocationNatPrefixCode, KCDTIdNatPrefixCode, NULL }, + { ECmLocationNatCode, KCDTIdNatCode, NULL }, + { ECmLocationAreaCode, KCDTIdAreaCode, NULL }, + { ECmLocationDialOutCode, KCDTIdDialOutCode, NULL }, + { ECmLocationDisableCallWaitingCode, KCDTIdDisableCallWaitingCode, NULL }, + { ECmLocationMobile, KCDTIdMobile, NULL }, + { ECmLocationUsePulseDial, KCDTIdUsePulseDial, NULL }, + { ECmLocationWaitForDialTone, KCDTIdWaitForDialTone, NULL }, + { ECmLocationPauseAfterDialOut, KCDTIdPauseAfterDialOut, NULL }, + { 0, 0, NULL }, + }; + +static const TCmAttribConvTable SWapConvTbl[] = + { + { ECmWapIPGatewayAddress, ECmWapRangeMax, NULL }, + { ECmWapIPGatewayAddress, KCDTIdWAPGatewayAddress, &CheckIPv4ValidityL }, + { ECmWapIPWSPOption, KCDTIdWAPWSPOption, &CheckWAPWspOptionValidityL }, + { ECmWapIPSecurity, KCDTIdWAPSecurity, NULL }, + { ECmWapIPProxyPort, KCDTIdWAPProxyPort, &CheckPortNumberValidityL }, + { ECmWapIPProxyLoginName, KCDTIdWAPProxyLoginName, NULL }, + { ECmWapIPProxyLoginPass, KCDTIdWAPProxyLoginPass, NULL }, + { 0, 0, NULL }, + }; + +static const TCmAttribConvTable SUiTable[] = + { + { ECmName, 0, NULL, + R_CMMANAGERUI_CONNECTION_NAME, + KMaxConnNameLength, EConvNoZeroLength | EConvCompulsory, 0, R_TEXT_SETTING_PAGE_CONN_NAME, NULL, NULL }, + { ECmBearerSettingName, 0, NULL, + R_PLUGIN_BASE_SET_AP_BEARER, + 0, 0, 0, 0, NULL, NULL }, + { ECmStartPage, 0, NULL, + R_QTN_SET_STARTING_PAGE, + KMaxStartPageLength, 0, R_QTN_SET_HOME_PAGE_NONE, R_TEXT_SETTING_PAGE_STARTING_PAGE, + R_START_PAGE_DEF_VALUE, NULL, NULL }, + { 0, 0, NULL, + 0, + 0, 0, 0, NULL, NULL }, + }; + +/** + * Private data of plugin base + */ +NONSHARABLE_CLASS( CCmPluginBasePrivate ) : public CBase + { + public: + + CCmPluginBasePrivate(); + ~CCmPluginBasePrivate(); + + public: + + CCDWAPAccessPointRecord* iWapAPRecord; + CCDWAPIPBearerRecord* iWapIPBearerRecord; + CCDIAPMetadataRecord* iMetaDataRecord; + + TNamingMethod iNamingMethod; + + CArrayPtrFlat* iConvTblArray; + RArray iCommonConvTblArray; + + TInt iLoadResult; + }; + +// ======== LOCAL FUNCTIONS ======== + +// --------------------------------------------------------------------------- +// ReadOnlyAttributeL +// --------------------------------------------------------------------------- +// +EXPORT_C TBool ReadOnlyAttributeL( CCmPluginBaseEng* aThis, + TUint32 aAttribute, + const TAny* aValue ) + { + User::Leave( KErrNotSupported ); + + (void)aThis; + (void)aAttribute; + (void)aValue; + + return EFalse; + } + +// --------------------------------------------------------------------------- +// CheckIPv4ValidityL +// --------------------------------------------------------------------------- +// +EXPORT_C TBool CheckIPv4ValidityL( CCmPluginBaseEng* aThis, + TUint32 aAttribute, + const TAny* aValue ) + { + (void)aThis; + (void)aAttribute; + (void)aValue; + + return EFalse; + } + +// --------------------------------------------------------------------------- +// CheckIPv6ValidityL +// --------------------------------------------------------------------------- +// +EXPORT_C TBool CheckIPv6ValidityL( CCmPluginBaseEng* aThis, + TUint32 aAttribute, + const TAny* aValue ) + { + (void)aThis; + (void)aAttribute; + (void)aValue; + + return EFalse; + } + +// --------------------------------------------------------------------------- +// CheckPortNumberValidityL +// --------------------------------------------------------------------------- +// +EXPORT_C TBool CheckPortNumberValidityL( CCmPluginBaseEng* aThis, + TUint32 aAttribute, + const TAny* aValue ) + { + (void)aThis; + (void)aAttribute; + (void)aValue; + + return EFalse; + } + +// --------------------------------------------------------------------------- +// CheckRecordIdValidityL +// --------------------------------------------------------------------------- +// +EXPORT_C TBool CheckRecordIdValidityL( CCmPluginBaseEng* aThis, + TUint32 aAttribute, + const TAny* aValue ) + { + TUint32 recId = *(TUint32*)aValue; + + if( recId < 1 || recId > 254 ) + { + CLOG_WRITE_1_PTR( aThis, "Not valid Rec id: [%d]", recId ); + User::Leave( KErrArgument ); + } + + (void)aThis; + (void)aAttribute; + (void)aValue; + + return EFalse; + } + +// --------------------------------------------------------------------------- +// CheckWAPWspOptionValidityL +// --------------------------------------------------------------------------- +// +EXPORT_C TBool CheckWAPWspOptionValidityL( CCmPluginBaseEng* aThis, + TUint32 aAttribute, + const TAny* aValue ) + { + TUint32 wspOpt = (TUint32)aValue; + + + if( wspOpt != ECmWapWspOptionConnectionless && + wspOpt != ECmWapWspOptionConnectionOriented ) + { + User::Leave( KErrArgument ); + } + + (void)aThis; + (void)aAttribute; + (void)aValue; + + return EFalse; + } + +// --------------------------------------------------------------------------- +// IsUnspecifiedIPv4Address +// --------------------------------------------------------------------------- +// +EXPORT_C TBool IsUnspecifiedIPv4Address( const TDesC& aIpv4Address ) + { + if( aIpv4Address.Length() == 0 || + !aIpv4Address.CompareF( KUnspecifiedIPv4 ) ) + { + return ETrue; + } + + return EFalse; + } + +// --------------------------------------------------------------------------- +// ClassifyIPv6Address +// --------------------------------------------------------------------------- +// +EXPORT_C TIPv6Types ClassifyIPv6Address( const TDesC& aIpv6Address ) + { + if( aIpv6Address.Length() == 0 || + !aIpv6Address.CompareF( KDynamicIpv6Address ) ) + { + return EIPv6Unspecified; + } + else if( !aIpv6Address.CompareF( KKnownIp6NameServer1 ) || + !aIpv6Address.CompareF( KKnownIp6NameServer2 ) ) + { + return EIPv6WellKnown; + } + + return EIPv6UserDefined; + } + +// --------------------------------------------------------------------------- +// SetProxyServerNameL +// --------------------------------------------------------------------------- +// +EXPORT_C TBool SetProxyServerNameL( CCmPluginBaseEng* aThis, + TUint32 /*aAttribute*/, + const TAny* aValue ) + { + const TDesC* proxyServer = (const TDesC*)aValue; + + return aThis->SetProxyServerNameL( *proxyServer ); + } + +// ======== MEMBER FUNCTIONS ======== + +// --------------------------------------------------------------------------- +// TCmPluginInitParam::TCmPluginInitParam +// --------------------------------------------------------------------------- +// +TCmPluginInitParam::TCmPluginInitParam( CCmManagerImpl& aCmMgr ) + : iCmMgr( aCmMgr ) + { + iParentDest = 0; + iNotused1 = NULL; + iNotused2 = NULL; + } + +// --------------------------------------------------------------------------- +// CCmPluginBasePrivate::CCmPluginBasePrivate +// --------------------------------------------------------------------------- +// +CCmPluginBasePrivate::CCmPluginBasePrivate() + : iNamingMethod( ENamingUnique ) + , iCommonConvTblArray( KDefAttrsArrayGranSize ) + { + } + +// --------------------------------------------------------------------------- +// CCmPluginBasePrivate::~CCmPluginBasePrivate +// --------------------------------------------------------------------------- +// +CCmPluginBasePrivate::~CCmPluginBasePrivate() + { + delete iWapAPRecord; + delete iWapIPBearerRecord; + delete iMetaDataRecord; + + if ( iConvTblArray ) + { + iConvTblArray->ResetAndDestroy(); + delete iConvTblArray; + } + + iCommonConvTblArray.Reset(); + iCommonConvTblArray.Close(); + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::CCmPluginBaseEng +// --------------------------------------------------------------------------- +// +EXPORT_C CCmPluginBaseEng::CCmPluginBaseEng( TCmPluginInitParam *aInitParam ) + : iCmMgr( aInitParam->iCmMgr ) + , iParentDest( aInitParam->iParentDest ) + { + CLOG_CREATE; + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::~CCmPluginBaseEng +// --------------------------------------------------------------------------- +// +EXPORT_C CCmPluginBaseEng::~CCmPluginBaseEng() + { + Reset(); + + delete iPriv; + + REComSession::DestroyedImplementation( iDtor_ID_Key ); + CLOG_CLOSE; + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::ConstructL +// --------------------------------------------------------------------------- +// +EXPORT_C void CCmPluginBaseEng::ConstructL() + { + LOGGER_ENTERFN( "CCmPluginBaseEng::ConstructL" ); + + iPriv = new (ELeave) CCmPluginBasePrivate; + + // 4 for our tables + 4 for bearer specific ones. + iPriv->iConvTblArray = new (ELeave)CArrayPtrFlat( 8 ); + + AddConverstionTableL( (CCDRecordBase**)&iIapRecord, + NULL, SIapConvTbl ); + AddConverstionTableL( (CCDRecordBase**)&iProxyRecord, + NULL, SProxyConvTbl ); + AddConverstionTableL( (CCDRecordBase**)&iChargeCardRecord, + &iChargeCardEnabled, SChargeCardConvTbl ); + AddConverstionTableL( (CCDRecordBase**)&iLocationRecord, + &iLocationEnabled, SLocationConvTbl ); + AddConverstionTableL( (CCDRecordBase**)&iPriv->iWapIPBearerRecord, + NULL, SWapConvTbl ); + } + + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::GetIntAttributeL +// --------------------------------------------------------------------------- +// +EXPORT_C TUint32 + CCmPluginBaseEng::GetIntAttributeL( const TUint32 aAttribute ) const + { + LOGGER_ENTERFN( "CCmPluginBaseEng::GetIntAttributeL" ); + + TUint32 retVal( 0 ); + + switch ( aAttribute ) + { + case ECmBearerIcon: + { + retVal = 0; // bearer doesn't provide any icon + } + break; + + case ECmBearerAvailableIcon: + { + retVal = 0; // bearer doesn't provide any icon + } + break; + + case ECmId: // if the CM has an IapId than the ECmId is the ECmId + case ECmIapId: + { + retVal = iIapId; + } + break; + case ECmWapId: + { + retVal = iPriv->iWapIPBearerRecord->iWAPAccessPointId; + } + break; + case ECmIapServiceId: + { + retVal = TUint32(iIapRecord->iService); + } + break; + case ECmBearerType: + { + retVal = iBearerType; + } + break; + + case ECmDefaultPriority: + { + retVal = KDataMobilitySelectionPolicyPriorityWildCard; + } + break; + + case ECmDefaultUiPriority: + { + retVal = KDataMobilitySelectionPolicyPriorityWildCard; + } + break; + + case ECmNamingMethod: + { + retVal = iPriv->iNamingMethod; + } + break; + + case ECmExtensionLevel: + { + retVal = KExtensionBaseLevel; + } + break; + + case ECmInvalidAttribute: + { + retVal = iInvalidAttribute; + } + break; + + case ECmCommsDBBearerType: + { + User::Leave( KErrUnknown ); + } + break; + + case ECmSeamlessnessLevel: + { + retVal = iPriv->iMetaDataRecord->iSeamlessness; + } + break; + + case ECmElementID: + { + if ( !iIapRecord ) + { + User::Leave( KErrNotReady ); + } + + retVal = (KCDMaskShowField & iIapRecord->ElementId()); + } + break; + + case ECmLoadResult: + { + retVal = iPriv->iLoadResult; + } + break; + + case ECmNetworkId: + { + retVal = iIapRecord->iNetwork; + } + break; + + default: + { + TUint32 attribute = CheckForCommonAttribute( aAttribute ); + CMDBField* field; + + FindFieldL( attribute, ECmInt, (CMDBElement*&)field ); + + retVal = *field; + } + break; + } + + return retVal; + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::GetBoolAttributeL +// --------------------------------------------------------------------------- +// +EXPORT_C TBool + CCmPluginBaseEng::GetBoolAttributeL( const TUint32 aAttribute ) const + { + LOGGER_ENTERFN( "CCmPluginBaseEng::GetBoolAttributeL" ); + + TBool retVal; + + switch ( aAttribute ) + { + case ECmProtected: + { + retVal = IsProtected(); + } + break; + + case ECmHidden: + { + retVal = iIapRecord->Attributes() & ECDHidden; + } + break; + + case ECmDestination: + { + retVal = EFalse; + } + break; + + case ECmChargeCardUsageEnabled: + { + retVal = iChargeCardEnabled; + } + break; + + case ECmCoverage: + // In default the plugin has no network coverage + { + retVal = EFalse; + } + break; + + case ECmAddToAvailableList: + { + retVal = EFalse; + } + break; + + case ECmBearerHasUi: + { + retVal = EFalse; + } + break; + + case ECmMetaHighlight: + { + retVal = iPriv->iMetaDataRecord->iMetadata & EMetaHighlight; + } + break; + + case ECmMetaHiddenAgent: + { + retVal = iPriv->iMetaDataRecord->iMetadata & EMetaHiddenAgent; + } + break; + + case ECmIPv6Supported: + { + retVal = FeatureSupported( KFeatureIdIPv6 ); + } + break; + + case ECmConnected: + { + retVal = CheckIfAlreadyConnected(); + } + break; + + case ECmVirtual: + { + retVal = EFalse; + } + break; + + case ECmIsLinked: + { + retVal = iCmMgr.IsIapLinkedL( *this ); + } + break; + + default: + { + TUint32 attribute = CheckForCommonAttribute( aAttribute ); + CMDBField* field; + + FindFieldL( attribute, ECmBool, (CMDBElement*&)field ); + + retVal = *field; + } + } + + return retVal; + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::GetStringAttributeL +// --------------------------------------------------------------------------- +// +EXPORT_C HBufC* + CCmPluginBaseEng::GetStringAttributeL( const TUint32 aAttribute ) const + { + LOGGER_ENTERFN( "CCmPluginBaseEng::GetStringAttributeL" ); + + HBufC* retVal = NULL; + + switch ( aAttribute ) + { + case ECmStartPage: + { + retVal = TPtrC(iPriv->iWapAPRecord->iWAPStartPage).AllocL(); + } + break; + + case ECmName: + { + retVal = TPtrC(iIapRecord->iRecordName).AllocL(); + } + break; + + default: + { + TUint32 attribute = CheckForCommonAttribute( aAttribute ); + CMDBField* field; + + FindFieldL( attribute, ECmText, (CMDBElement*&)field ); + + if ( !field->IsNull() ) + { + retVal = field->GetL().AllocL(); + } + else + { + retVal = KNullDesC().AllocL(); + } + } + } + + return retVal; + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::GetString8AttributeL +// --------------------------------------------------------------------------- +// +EXPORT_C HBufC8* + CCmPluginBaseEng::GetString8AttributeL( const TUint32 aAttribute ) const + { + LOGGER_ENTERFN( "CCmPluginBaseEng::GetString8AttributeL" ); + + HBufC8* retVal = NULL; + + TUint32 attribute = CheckForCommonAttribute( aAttribute ); + CMDBField* field; + + FindFieldL( attribute, ECmText8, (CMDBElement*&)field ); + + if ( !field->IsNull() ) + { + retVal = field->GetL().AllocL(); + } + else + { + retVal = KNullDesC8().AllocL(); + } + + return retVal; + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::SetIntAttributeL +// --------------------------------------------------------------------------- +// +EXPORT_C void CCmPluginBaseEng::SetIntAttributeL( const TUint32 aAttribute, + TUint32 aValue ) + { + LOGGER_ENTERFN( "CCmPluginBaseEng::SetIntAttributeL" ); + + switch ( aAttribute ) + { + case ECmNamingMethod: + { + iPriv->iNamingMethod = (TNamingMethod)aValue; + } + break; + + case ECmCommsDBBearerType: + case ECmElementID: + case ECmIapId: + case ECmId: + { + User::Leave( KErrNotSupported ); + } + break; + + case ECmSeamlessnessLevel: + { + if ( aValue == ESeamlessnessConfirmFirst || + aValue == ESeamlessnessShowprogress ) + { + iPriv->iMetaDataRecord->iSeamlessness = aValue; + } + else + { + User::Leave( KErrNotSupported ); + } + } + break; + + case ECmNetworkId: + { + User::Leave( KErrNotSupported ); + } + break; + + default: + { + TUint32 attribute = CheckForCommonAttribute( aAttribute ); + CMDBField* field; + + TValidationFunctionL func = + FindFieldL( attribute, ECmInt, (CMDBElement*&)field ); + + if( func ) + { + func( this, attribute, (TAny*)aValue ); + } + + *field = aValue; + } + break; + } + + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::SetBoolAttributeL +// --------------------------------------------------------------------------- +// +EXPORT_C void CCmPluginBaseEng::SetBoolAttributeL( const TUint32 aAttribute, + TBool aValue ) + { + LOGGER_ENTERFN( "CCmPluginBaseEng::SetBoolAttributeL" ); + + switch ( aAttribute ) + { + case ECmProtected: + { + SetAttribute( iIapRecord, ECDProtectedWrite, aValue ); + } + break; + + case ECmHidden: + { + // Check that this is not Default Connection + TCmDefConnValue defConn; + iCmMgr.ReadDefConnL( defConn ); + if ( defConn.iType == ECmDefConnConnectionMethod && + defConn.iId == iIapRecord->RecordId() ) + { + User::Leave( KErrArgument ); + } + + SetAttribute( iIapRecord, ECDHidden, aValue ); + } + break; + + case ECmProxyUsageEnabled: + { + EnableProxyL( aValue ); + } + break; + + case ECmChargeCardUsageEnabled: + { + EnableChargeCardL( aValue ); + } + break; + + case ECmLocationUsageEnabled: + { + EnableLocationL( aValue ); + } + break; + + case ECmMetaHighlight: + { + if( aValue ) + { + iPriv->iMetaDataRecord->iMetadata = + EMetaHighlight | iPriv->iMetaDataRecord->iMetadata; + } + else + { + iPriv->iMetaDataRecord->iMetadata = + ~EMetaHighlight & iPriv->iMetaDataRecord->iMetadata; + } + } + break; + + case ECmMetaHiddenAgent: + { + if( aValue ) + { + iPriv->iMetaDataRecord->iMetadata = + EMetaHiddenAgent | iPriv->iMetaDataRecord->iMetadata; + } + else + { + iPriv->iMetaDataRecord->iMetadata = + ~EMetaHiddenAgent & iPriv->iMetaDataRecord->iMetadata; + } + } + break; + + default: + { + TUint32 attribute = CheckForCommonAttribute( aAttribute ); + CMDBField* field; + + TValidationFunctionL func = + FindFieldL( attribute, ECmBool, (CMDBElement*&)field ); + + if( func ) + { + func( this, attribute, (const TAny*)aValue ); + } + + + *field = aValue; + } + } + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::SetStringAttributeL +// --------------------------------------------------------------------------- +// +EXPORT_C void CCmPluginBaseEng::SetStringAttributeL( const TUint32 aAttribute, + const TDesC16& aValue ) + { + LOGGER_ENTERFN( "CCmPluginBaseEng::SetStringAttributeL" ); + + TUint32 commonattribute = MappedCommonAttribute( aAttribute ); + switch ( commonattribute ) + { + case ECmStartPage: + { + iPriv->iWapAPRecord->iWAPStartPage.SetL( aValue ); + } + break; + + case ECmName: + { + SetNameL( aValue ); + } + break; + case ECmIPAddress: + { + GenericStringWriterL( commonattribute, aValue ); + if (( aValue.Compare(KUnspecifiedIPv4) == 0) || ( aValue.Compare(KNullDesC)==0 ) ) + { + SetBoolAttributeL( ECmIPAddFromServer, ETrue ); + } + else + { + SetBoolAttributeL( ECmIPAddFromServer, EFalse ); + } + } + break; + default: + { + GenericStringWriterL( commonattribute, aValue ); + } + } + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::SetString8AttributeL +// --------------------------------------------------------------------------- +// +EXPORT_C void CCmPluginBaseEng::SetString8AttributeL( const TUint32 aAttribute, + const TDesC8& aValue ) + { + LOGGER_ENTERFN( "CCmPluginBaseEng::SetString8AttributeL" ); + + TUint32 attribute = CheckForCommonAttribute( aAttribute ); + CMDBField* field; + + TValidationFunctionL func = FindFieldL( attribute, ECmText8, (CMDBElement*&)field ); + + if( func ) + { + func( this, attribute, (const TAny*)&aValue ); + } + + field->SetL( aValue ); + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::RestoreAttributeL +// --------------------------------------------------------------------------- +// +EXPORT_C void CCmPluginBaseEng::RestoreAttributeL( const TUint32 aAttribute ) + { + LOGGER_ENTERFN( "CCmPluginBaseEng::RestoreAttributeL" ); + + TCmAttrConvArrayItem* item = ConversionTable( aAttribute ); + + TInt index( 0 ); + CMDBElement& field = FieldByAttributeL( item, aAttribute, index ); + + TRAPD( err, field.LoadL( Session() ) ); + if( err == KErrNotFound ) + { + switch ( field.Type() ) + { + case EText: + case EMedText: + case ELongText: + { + CMDBField* textField = static_cast*>( &field ); + + textField->SetL( KNullDesC ); + } + break; + + case EDesC8: + { + CMDBField* textField = static_cast*>( &field ); + + textField->SetL( KNullDesC8 ); + } + break; + + case EUint32: + case EInt: + case EBool: + { + CMDBField* intField = static_cast*>( &field ); + + intField->SetL( 0 ); + } + break; + + default: + { + User::Leave( KErrArgument ); + } + break; + } + } + else + { + User::LeaveIfError( err ); + } + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::Destination +// --------------------------------------------------------------------------- +// +EXPORT_C CCmDestinationImpl* CCmPluginBaseEng::Destination() const + { + LOGGER_ENTERFN( "CCmPluginBaseEng::Destination" ); + + return NULL; + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::UpdateL +// --------------------------------------------------------------------------- +// +EXPORT_C void CCmPluginBaseEng::UpdateL() + { + LOGGER_ENTERFN( "CCmPluginBaseEng::UpdateL" ); + + CheckSpaceBelowCriticalLevelL(); + + OpenTransactionLC(); + + PrepareToUpdateRecordsL(); + + UpdateChargeCardRecordL(); + UpdateServiceRecordL(); + + UpdateLocationRecordL(); + UpdateNetworkRecordL(); + + UpdateIAPRecordL(); + + UpdateWapRecordL(); + UpdateProxyRecordL(); + UpdateSeamlessnessRecordL(); + UpdateConnPrefSettingL(); + + UpdateAdditionalRecordsL(); + + CommitTransactionL( 0 ); + iCmMgr.ConnMethodUpdatedL( this ); + iIdIsValid = ETrue; + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::NumOfConnMethodReferencesL +// --------------------------------------------------------------------------- +// +EXPORT_C TInt CCmPluginBaseEng::NumOfConnMethodReferencesL() + { + LOGGER_ENTERFN( "CCmPluginBaseEng::NumOfConnMethodReferencesL" ); + + return iCmMgr.NumOfConnMethodReferencesL( iIapId ); + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::Session +// --------------------------------------------------------------------------- +// +EXPORT_C CMDBSession& CCmPluginBaseEng::Session()const + { + LOGGER_ENTERFN( "CCmPluginBaseEng::Session" ); + + return iCmMgr.Session(); + } + +// --------------------------------------------------------------------------- +// Delete this connection methond. +// Record ids are checked to be sure that we delete only records +// that were loaded before. +// --------------------------------------------------------------------------- +// +EXPORT_C TBool CCmPluginBaseEng::DeleteL( TBool aForced, + TBool aOneRefAllowed ) + { + LOGGER_ENTERFN( "CCmPluginBaseEng::DeleteL" ); + + if ( CheckIfAlreadyConnected() ) + { + User::Leave( KErrInUse ); + } + + if( iPriv->iLoadResult ) + // previous load failed -> do NOT delete this partially loaded cm. + { + User::Leave( KErrNotReady ); + } + + if( GetBoolAttributeL( ECmIsLinked ) ) + { + User::Leave( KErrLocked ); + } + + // If there is no parent destination, we can delete + TBool retVal(ETrue); + + if( !aForced ) + { + TInt refs = NumOfConnMethodReferencesL(); + + switch ( refs ) + { + case 0: + // no referencies to this cm + { + CLOG_WRITE( "No ref -> do delete it" ); + } + break; + + case 1: + // one reference + { + if ( !aOneRefAllowed ) + // this is not a legacy cm -> cannot be deleted. + { + retVal = EFalse; + } + } + break; + + default: + // connection method is multiple referenced from + // destinations -> no delete + { + retVal = EFalse; + } + break; + } + } + + if ( retVal ) + { + TCmDefConnValue deletedItem; + deletedItem.iType = ECmDefConnConnectionMethod; + deletedItem.iId = iIapId; + iCmMgr.HandleDefConnDeletedL( deletedItem ); + + if( aForced ) + { + iCmMgr.RemoveAllReferencesWoTransL( *this ); + } + + OpenTransactionLC(); + // And now we have everything from CommsDat, + // so we delete only those records. + PrepareToDeleteRecordsL(); + + if ( iIapRecord && iIapRecord->RecordId() ) + { + iIapRecord->DeleteL( Session() ); + } + + if ( iProxyRecord && iProxyRecord->RecordId() ) + { + iProxyRecord->DeleteL( Session() ); + } + + if ( iServiceRecord && iServiceRecord->RecordId() ) + { + iServiceRecord->DeleteL( Session() ); + } + + if ( iChargeCardRecord && iChargeCardRecord->RecordId() ) + { + iChargeCardRecord->DeleteL( Session() ); + } + + if ( iNetworkRecord && iNetworkRecord->RecordId() ) + { + iNetworkRecord->DeleteL( Session() ); + } + + if ( iLocationRecord && iLocationRecord->RecordId() ) + { + iLocationRecord->DeleteL( Session() ); + } + + if ( iPriv->iWapAPRecord && + iPriv->iWapAPRecord->RecordId() ) + { + iPriv->iWapAPRecord->DeleteL( Session() ); + } + + if ( iPriv->iWapIPBearerRecord && + iPriv->iWapIPBearerRecord->RecordId() ) + { + iPriv->iWapIPBearerRecord->DeleteL( Session() ); + } + + if ( iPriv->iMetaDataRecord && + iPriv->iMetaDataRecord->RecordId() ) + { + iPriv->iMetaDataRecord->DeleteL( Session() ); + } + + DeleteAdditionalRecordsL(); + + CommitTransactionL( KErrNone ); + } + + return retVal; + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::LoadL +// --------------------------------------------------------------------------- +// +EXPORT_C void CCmPluginBaseEng::LoadL( TUint32 aIapId ) + { + LOGGER_ENTERFN( "CCmPluginBaseEng::LoadL" ); + CLOG_NAME_2( _L("plugin_0x%x_%d"), this, aIapId ); + + OpenTransactionLC(); + + // trap it to set iPriv->iLoadResult + TRAP( iPriv->iLoadResult, DoLoadL( aIapId ) ); + + User::LeaveIfError( iPriv->iLoadResult ); + + RollbackTransaction(); + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::CreateNewL +// --------------------------------------------------------------------------- +// +EXPORT_C void CCmPluginBaseEng::CreateNewL() + { + LOGGER_ENTERFN( "CCmPluginBaseEng::CreateNewL" ); + + CheckSpaceBelowCriticalLevelL(); + + if ( iIapId ) + // we already have IAP id -> + { + User::Leave( KErrAlreadyExists ); + } + + iPreDefIapId = 0; + + // optional record are disable in default + iChargeCardEnabled = EFalse; + iLocationEnabled = EFalse; + + // create mandatory records + iIapRecord = static_cast + (CCDRecordBase::RecordFactoryL(KCDTIdIAPRecord)); + iNetworkRecord = static_cast + (CCDRecordBase::RecordFactoryL(KCDTIdNetworkRecord)); + iProxyRecord = static_cast + (CCDRecordBase::RecordFactoryL(KCDTIdProxiesRecord)); + NewWapRecordL(); + iPriv->iWapIPBearerRecord->iWAPGatewayAddress.SetL( + KDefWapGatewayIpAddress ); + + iPriv->iMetaDataRecord = NewSeamlessnessRecordL( ETrue ); + + // call plugin to create its own records + CreateNewServiceRecordL(); + CreateAdditionalRecordsL(); + + EnableProxyL( EFalse ); + + // Load default CM name from resource + HBufC* defApName = AllocReadL( R_CMMANAGERENG_DEFAULT_AP_NAME ); + CleanupStack::PushL( defApName ); + + SetNameL( *defApName ); + + CleanupStack::PopAndDestroy( defApName ); + + iIapRecord->iNetworkWeighting = 0; // it's always 0. + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::CreateCopyL +// --------------------------------------------------------------------------- +// +EXPORT_C CCmPluginBaseEng* CCmPluginBaseEng::CreateCopyL() const + { + LOGGER_ENTERFN( "CCmPluginBaseEng::CreateCopyL" ); + CheckSpaceBelowCriticalLevelL(); + + TCmPluginInitParam params( iCmMgr ); + + CCmPluginBaseEng* copyInst = CreateInstanceL( params ); + CleanupStack::PushL( copyInst ); + + copyInst->CreateNewL(); + + TInt err( KErrNone ); + TRAP( err, copyInst->SetBoolAttributeL( ECmChargeCardUsageEnabled, iChargeCardEnabled ) ); + if( err != KErrNotSupported ) + { + User::LeaveIfError( err ); + } + TRAP( err, copyInst->SetBoolAttributeL( ECmLocationUsageEnabled, iLocationEnabled ) ); + if( err != KErrNotSupported ) + { + User::LeaveIfError( err ); + } + copyInst->SetIntAttributeL( ECmNamingMethod, iPriv->iNamingMethod ); + copyInst->SetStringAttributeL( ECmName, TPtrC( iIapRecord->iRecordName ) ); + copyInst->SetStringAttributeL( ECmStartPage, TPtrC( iPriv->iWapAPRecord->iWAPStartPage ) ); + + + PrepareToCopyDataL( *copyInst ); + + for ( TInt tblInd = 0; tblInd < iPriv->iConvTblArray->Count(); ++tblInd ) + { + const TCmAttrConvArrayItem* item = (*iPriv->iConvTblArray)[tblInd]; + + if ( item->iEnabled && !(*item->iEnabled) ) + // Enabled flag is set to 'disabled' state + { + continue; + } + + if( !item->iRecord || + (item->iRecord && !(*item->iRecord)) ) + // no record + { + continue; + } + + for ( TInt attrInd = 1; item->iConvTable[attrInd].iAttribId; ++attrInd ) + { + if( item->iConvTable[attrInd].iAttribFlags & EConvReadOnly ) + // Read-only flags are not copied. + { + continue; + } + + TInt commsdatid( item->iConvTable[attrInd].iCommsDatId ); + + if ( !commsdatid ) + { // not connected to the DB, calculated field, no copy + continue; + } + + CMDBElement* field = (*item->iRecord)->GetFieldByIdL( commsdatid ); + + if( field->IsNull() ) + { + continue; + } + + switch ( field->Type() ) + { + case EText: + case EMedText: + case ELongText: + { + CMDBField* textField = (CMDBField*)field; + + TRAP( err, copyInst->SetStringAttributeL( + item->iConvTable[attrInd].iAttribId, + *textField ) ); + if( err != KErrNotSupported ) + { + User::LeaveIfError( err ); + } + } + break; + + case EDesC8: + { + CMDBField* textField = (CMDBField*)field; + + TRAP( err, copyInst->SetString8AttributeL( + item->iConvTable[attrInd].iAttribId, + *textField ) ); + if( err != KErrNotSupported ) + { + User::LeaveIfError( err ); + } + } + break; + + case EUint32: + case EInt: + { + CMDBField* intField = (CMDBField*)field; + + TRAP( err, copyInst->SetIntAttributeL( + item->iConvTable[attrInd].iAttribId, + *intField ) ); + if ( !(( err == KErrNotSupported ) || ( err == KErrArgument )) ) + { + User::LeaveIfError( err ); + } + } + break; + + case EBool: + { + CMDBField* intField = (CMDBField*)field; + + TRAP( err, copyInst->SetBoolAttributeL( + item->iConvTable[attrInd].iAttribId, + *intField ) ); + if( err != KErrNotSupported ) + { + User::LeaveIfError( err ); + } + } + break; + + case ELink: // links are not copied! + default: + { + } + break; + } + } + } + + CopyAdditionalDataL( *copyInst ); + + CleanupStack::Pop( copyInst ); + + return copyInst; + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::AddResourceFileL +// --------------------------------------------------------------------------- +// +EXPORT_C void CCmPluginBaseEng::AddResourceFileL( const TDesC& aName ) + { + LOGGER_ENTERFN( "CCmPluginBaseEng::AddResourceFileL" ); + + CLOG_WRITE_1( "[%S]", &aName ); + + TParse fp; + TInt err = fp.Set( aName, + &KDC_RESOURCE_FILES_DIR, + NULL ); + if ( err != KErrNone) + { + User::Leave( err ); + } + + TFileName fName; + + fName.Copy( fp.FullName() ); + + iCmMgr.AddResourceFileL( fName ); + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::RemoveResourceFile +// --------------------------------------------------------------------------- +// +EXPORT_C void CCmPluginBaseEng::RemoveResourceFile( const TDesC& aName ) + { + LOGGER_ENTERFN( "CCmPluginBaseEng::RemoveResourceFileL" ); + + TParse fp; + TInt err = fp.Set( aName, + &KDC_RESOURCE_FILES_DIR, + NULL ); + CLOG_WRITE_1( "Set: [%d]", err ); + + TFileName fName; + + fName.Copy( fp.FullName() ); + + iCmMgr.RemoveResourceFile( fName ); + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::AllocReadL +// --------------------------------------------------------------------------- +// +EXPORT_C HBufC* CCmPluginBaseEng::AllocReadL( TInt aResourceId ) const + { + LOGGER_ENTERFN( "CCmPluginBaseEng::AllocReadL" ); + + return iCmMgr.AllocReadL( aResourceId ); + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::OpenTransactionLC +// --------------------------------------------------------------------------- +// +void CCmPluginBaseEng::OpenTransactionLC() + { + LOGGER_ENTERFN( "CCmPluginBaseEng::OpenTransactionL" ); + + iCmMgr.OpenTransactionLC( ETrue ); + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::CommitTransactionL +// --------------------------------------------------------------------------- +// +void CCmPluginBaseEng::CommitTransactionL( TInt aError ) + { + LOGGER_ENTERFN( "CCmPluginBaseEng::CommitTransactionL" ); + + iCmMgr.CommitTransactionL( aError ); + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::RollbackTransaction +// --------------------------------------------------------------------------- +// +void CCmPluginBaseEng::RollbackTransaction() + { + LOGGER_ENTERFN( "CCmPluginBaseEng::RollbackTransaction" ); + + iCmMgr.RollbackTransaction(); + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::PrepareToLoadRecordsL +// --------------------------------------------------------------------------- +// +void CCmPluginBaseEng::DoLoadL( TUint32 aIapId ) + { + LOGGER_ENTERFN( "CCmPluginBaseEng::DoLoadL" ); + + PrepareToLoadRecordsL(); + + LoadIAPRecordL( aIapId ); + LoadWapRecordL(); + LoadSeamlessnessRecordL(); + LoadNetworkSettingL(); + LoadLocationSettingL(); + + // This is a connectionmethodinfo instance, that has no + // service and proxy setting. + if( KDummyBearerType != iBearerType ) + { + LoadServiceSettingL(); + LoadProxySettingL(); + } + + LoadAdditionalRecordsL(); + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::PrepareToLoadRecordsL +// --------------------------------------------------------------------------- +// +EXPORT_C void CCmPluginBaseEng::PrepareToLoadRecordsL() + { + LOGGER_ENTERFN( "CCmPluginBaseEng::PrepareToLoadRecordsL" ); + + iChargeCardEnabled = EFalse; + iLocationEnabled = EFalse; + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::LoadIAPRecordL +// --------------------------------------------------------------------------- +// +void CCmPluginBaseEng::LoadIAPRecordL( TUint32 aIapId ) + { + LOGGER_ENTERFN( "CCmPluginBaseEng::LoadIAPRecordL" ); + + iIapId = aIapId; + + // Load IAP record + CCDIAPRecord *iapRecord = static_cast + (CCDRecordBase::RecordFactoryL(KCDTIdIAPRecord)); + + CleanupStack::PushL( iapRecord ); + + iapRecord->SetRecordId( iIapId ); + + iapRecord->LoadL( Session() ); + + CleanupStack::Pop( iapRecord ); + + iIapRecord = iapRecord; + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::LoadProxySettingL +// --------------------------------------------------------------------------- +// +void CCmPluginBaseEng::LoadProxySettingL() + { + LOGGER_ENTERFN( "CCmPluginBaseEng::LoadProxySettingL" ); + + // Load Proxy record + CMDBRecordSet* proxieRS = + new(ELeave) CMDBRecordSet(KCDTIdProxiesRecord); + CleanupStack::PushL(proxieRS); + + // Now try to find the linked proxy record + // create new record + CCDProxiesRecord* proxyRecord = static_cast + (CCDRecordBase::RecordFactoryL(KCDTIdProxiesRecord)); + + CleanupStack::PushL( proxyRecord ); + + // Prime record + TPtrC serviceType( iIapRecord->iServiceType ); + + proxyRecord->iServiceType.SetL( serviceType ); + + proxieRS->iRecords.AppendL( proxyRecord ); + + CleanupStack::Pop( proxyRecord ); + + proxyRecord = NULL; + + CLOG_WRITE_1( "Looking for proxy: [%d]", TUint32(iIapRecord->iService) ); + + if ( proxieRS->FindL(Session()) ) + { + TInt i(0); + while( iiRecords.Count() ) + // Now that we have a list of services with the proper service type + // search for our proxy record and remove it from the array, + // then destroy the array. + { + CCDProxiesRecord* proxyRecord = (*proxieRS)[i]; + + // Compare the record id of these 2 services + if ( TUint32(proxyRecord->iService) == + TUint32(iIapRecord->iService) ) + { + iProxyRecord = proxyRecord; + // take ownership of this record + proxieRS->iRecords.Remove( i ); + break; + } + ++i; + } + } + + proxieRS->iRecords.ResetAndDestroy(); + + if( !iProxyRecord ) + { + // This creates a proxy record, where usage is disabled. + EnableProxyL( EFalse ); + } + + CleanupStack::PopAndDestroy( proxieRS ); + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::LoadServiceSettingL +// --------------------------------------------------------------------------- +// +EXPORT_C void CCmPluginBaseEng::LoadServiceSettingL() + { + LOGGER_ENTERFN( "CCmPluginBaseEng::LoadServiceSettingL" ); + + if ( iServiceRecord ) + { + iServiceRecord->SetRecordId( iIapRecord->iService ); + TRAPD( err, iServiceRecord->LoadL( Session() ) ); + if( err == KErrNotFound ) + // record not found -> create a default one + { + CreateNewServiceRecordL(); + } + else + { + User::LeaveIfError( err ); + } + } + else + { + CLOG_WRITE( "CCmPluginBaseEng::LoadServiceSettingL: No service rec" ); + } + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::LoadChargeCardSettingL +// --------------------------------------------------------------------------- +// +void CCmPluginBaseEng::LoadChargeCardSettingL( TUint32 aRecordId ) + { + LOGGER_ENTERFN( "CCmPluginBaseEng::LoadChargeCardSettingL" ); + + if ( !aRecordId ) + // No charge card is link to this IAP + { + iChargeCardEnabled = EFalse; + + CLOG_WRITE( "CCmPluginBaseEng::LoadChargeCardSettingL: No charge card" ); + return; + } + + iChargeCardRecord = static_cast + (CCDRecordBase::RecordFactoryL(KCDTIdChargecardRecord)); + iChargeCardRecord->SetRecordId( aRecordId ); + TRAPD( err, iChargeCardRecord->LoadL( Session() ) ); + if( err == KErrNotFound ) + // referenced but doesn't exist. Try to fix it. + { + iChargeCardRecord->SetRecordId( KCDNewRecordRequest ); + + // if it fails we can't do anything to solve this problem + iChargeCardRecord->StoreL( Session() ); + } + else + { + User::LeaveIfError( err ); + } + + iChargeCardEnabled = ETrue; + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::LoadNetworkSettingL +// --------------------------------------------------------------------------- +// +void CCmPluginBaseEng::LoadNetworkSettingL() + { + LOGGER_ENTERFN( "CCmPluginBaseEng::LoadNetworkSettingL" ); + + CCDNetworkRecord* networkRecord = static_cast + (CCDRecordBase::RecordFactoryL(KCDTIdNetworkRecord)); + CleanupStack::PushL( networkRecord ); + + networkRecord->SetRecordId( iIapRecord->iNetwork ); + TRAPD( err, networkRecord->LoadL( Session() ) ); + if( err == KErrNotFound ) + { + CleanupStack::PopAndDestroy( networkRecord ); + + networkRecord = static_cast + (CCDRecordBase::RecordFactoryL(KCDTIdNetworkRecord)); + } + else + // KErrNotFound -> doesn't matter. We will do it UpdateL() + { + User::LeaveIfError( err ); + + CleanupStack::Pop( networkRecord ); + } + + iNetworkRecord = networkRecord; + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::LoadLocationSettingL +// --------------------------------------------------------------------------- +// +void CCmPluginBaseEng::LoadLocationSettingL() + { + LOGGER_ENTERFN( "CCmPluginBaseEng::LoadLocationSettingL" ); + + CCDLocationRecord* locationRecord = static_cast + (CCDRecordBase::RecordFactoryL(KCDTIdLocationRecord)); + + CleanupStack::PushL( locationRecord ); + + locationRecord->SetRecordId( iIapRecord->iLocation ); + if ( locationRecord->FindL(Session()) ) + { + iLocationEnabled = ETrue; + + iLocationRecord = locationRecord; + + CleanupStack::Pop( locationRecord ); + } + else + { + iLocationEnabled = EFalse; + + CleanupStack::PopAndDestroy( locationRecord ); + } + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::PrepareToUpdateRecordsL +// --------------------------------------------------------------------------- +// +EXPORT_C void CCmPluginBaseEng::PrepareToUpdateRecordsL() + { + LOGGER_ENTERFN( "CCmPluginBaseEng::PrepareToUpdateRecordsL" ); + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::UpdateIAPRecordL +// --------------------------------------------------------------------------- +// +void CCmPluginBaseEng::UpdateIAPRecordL() + { + LOGGER_ENTERFN( "CCmPluginBaseEng::UpdateIAPRecordL" ); + + if ( !iIapId ) + { + if ( iPreDefIapId ) + { + iIapRecord->SetRecordId( iPreDefIapId ); + iPreDefIapId = 0; + } + else + { + iIapRecord->SetRecordId( KCDNewRecordRequest ); + } + + TUint32 id; + HBufC* name; + + ServiceRecordIdLC( name, id ); + iIapRecord->iService = id; + iIapRecord->iServiceType.SetL( *name ); + CleanupStack::PopAndDestroy( name ); + + BearerRecordIdLC( name, id ); + iIapRecord->iBearer = id; + iIapRecord->iBearerType.SetL( *name ); + CleanupStack::PopAndDestroy( name ); + + iIapRecord->iNetwork = iNetworkRecord->RecordId(); + + if ( iLocationRecord ) + { + iIapRecord->iLocation = iLocationRecord->RecordId(); + } + + iIapRecord->iLocation = GetLocationIdL(); + + iIapRecord->StoreL( Session() ); + iIapId = iIapRecord->RecordId(); + + CLOG_NAME_2( _L("plugin_0x%x_%d"), this, iIapId ); + CLOG_WRITE_1( "New IapId: [%d]", iIapId ); + } + else + { + iIapRecord->ModifyL( Session() ); + } + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::UpdateProxyRecordL +// --------------------------------------------------------------------------- +// +void CCmPluginBaseEng::UpdateProxyRecordL() + { + LOGGER_ENTERFN( "CCmPluginBaseEng::UpdateProxyRecordL" ); + + CopyAttributes( iIapRecord, iProxyRecord ); + CheckIfNameModifiedL( iProxyRecord ); + + if ( iProxyRecord->iUseProxyServer ) + { + if ( !iProxyRecord->RecordId() ) + // new proxy setting -> create new record + { + iProxyRecord->iService = iServiceRecord->RecordId(); + iProxyRecord->iServiceType.SetL( iIapRecord->iServiceType ); + + // By default protocol is set to "http" + if ( TPtrC(iProxyRecord->iProtocolName).Length() == 0 ) + { + iProxyRecord->iProtocolName.SetL(KDefProxyProtocolName); + } + + iProxyRecord->SetRecordId( KCDNewRecordRequest ); + + iProxyRecord->StoreL( Session() ); + } + else + // already existing record -> update only + { + iProxyRecord->ModifyL( Session() ); + } + } + else + { + if ( iProxyRecord->RecordId() ) + { + iProxyRecord->DeleteL( Session() ); + } + } + } + + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::UpdateSeamlessnessRecordL +// --------------------------------------------------------------------------- +// +void CCmPluginBaseEng::UpdateSeamlessnessRecordL() + { + LOGGER_ENTERFN( "CCmPluginBaseEng::UpdateSeamlessnessRecordL" ); + + CopyAttributes( iIapRecord, iPriv->iMetaDataRecord ); + CheckIfNameModifiedL( iPriv->iMetaDataRecord ); + + if ( !iPriv->iMetaDataRecord->RecordId() ) + { + iPriv->iMetaDataRecord->iIAP = IAPRecordElementId(); + iPriv->iMetaDataRecord->SetRecordId( KCDNewRecordRequest ); + iPriv->iMetaDataRecord->StoreL( Session() ); + } + else + { + iPriv->iMetaDataRecord->ModifyL( Session() ); + } + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::UpdateChargeCardRecordL +// --------------------------------------------------------------------------- +// +void CCmPluginBaseEng::UpdateChargeCardRecordL() + { + LOGGER_ENTERFN( "CCmPluginBaseEng::UpdateChargeCardRecordL" ); + if ( iChargeCardEnabled ) + { + CopyAttributes( iIapRecord, iChargeCardRecord ); + CheckIfNameModifiedL( iChargeCardRecord ); + + if ( !iChargeCardRecord->RecordId() ) + { + iChargeCardRecord->SetRecordId( KCDNewRecordRequest ); + iChargeCardRecord->StoreL( Session() ); + } + else + { + iChargeCardRecord->ModifyL( Session() ); + } + } + else + { + if ( iChargeCardRecord ) + { + iChargeCardRecord->DeleteL( Session() ); + } + } + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::UpdateServiceRecordL +// --------------------------------------------------------------------------- +// +EXPORT_C void CCmPluginBaseEng::UpdateServiceRecordL() + { + LOGGER_ENTERFN( "CCmPluginBaseEng::UpdateServiceRecordL" ); + + if ( iServiceRecord ) + { + CopyAttributes( iIapRecord, iServiceRecord ); + CheckIfNameModifiedL( iServiceRecord ); + + if ( !iServiceRecord->RecordId() ) + { + iServiceRecord->SetRecordId( KCDNewRecordRequest ); + iServiceRecord->StoreL( Session() ); + } + else + { + iServiceRecord->ModifyL( Session() ); + } + } + else + { + CLOG_WRITE( "No service record" ); + } + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::UpdateNetworkRecordL +// --------------------------------------------------------------------------- +// +void CCmPluginBaseEng::UpdateNetworkRecordL() + { + LOGGER_ENTERFN( "CCmPluginBaseEng::UpdateNetworkRecordL" ); + + CopyAttributes( iIapRecord, iNetworkRecord ); + if ( !iNetworkRecord->RecordId() ) + { + CheckIfNameModifiedL( iNetworkRecord ); + + iNetworkRecord->SetRecordId( KCDNewRecordRequest ); + iNetworkRecord->StoreL( Session() ); + } + else + { + iNetworkRecord->ModifyL( Session() ); + } + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::UpdateLocationRecordL +// --------------------------------------------------------------------------- +// +void CCmPluginBaseEng::UpdateLocationRecordL() + { + LOGGER_ENTERFN( "CCmPluginBaseEng::UpdateLocationRecordL" ); + if ( iLocationEnabled ) + { + CopyAttributes( iIapRecord, iLocationRecord ); + CheckIfNameModifiedL( iLocationRecord ); + + if ( !iLocationRecord->RecordId() ) + { + iLocationRecord->SetRecordId( KCDNewRecordRequest ); + iLocationRecord->StoreL( Session() ); + } + else + { + iLocationRecord->ModifyL( Session() ); + } + } + else + { + if ( iLocationRecord ) + { + iLocationRecord->DeleteL( Session() ); + } + } + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::UpdateConnPrefSettingL +// --------------------------------------------------------------------------- +// +void CCmPluginBaseEng::UpdateConnPrefSettingL() + { + LOGGER_ENTERFN( "CCmPluginBaseEng::UpdateConnPrefSettingL" ); + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::EnableProxyL +// --------------------------------------------------------------------------- +// +void CCmPluginBaseEng::EnableProxyL( TBool aEnable ) + { + LOGGER_ENTERFN( "CCmPluginBaseEng::EnableProxyL" ); + + if ( !iServiceRecord ) + { + CLOG_WRITE( "No service record -> no proxy" ); + User::Leave( KErrNotSupported ); + } + + if( !iProxyRecord ) + { + iProxyRecord = static_cast + (CCDRecordBase::RecordFactoryL(KCDTIdProxiesRecord)); + } + + iProxyRecord->iUseProxyServer = aEnable; + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::EnableChargeCardL +// --------------------------------------------------------------------------- +// +void CCmPluginBaseEng::EnableChargeCardL( TBool aEnable ) + { + LOGGER_ENTERFN( "CCmPluginBaseEng::EnableChargeCardL" ); + + if ( aEnable ) + { + if ( !iChargeCardRecord ) + { + iChargeCardRecord = static_cast + (CCDRecordBase::RecordFactoryL(KCDTIdChargecardRecord)); + } + } + else + // charge card is disabled. To be deleted in UpdateL + // Nothing to do here + { + } + + iChargeCardEnabled = aEnable; + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::EnableLocationL +// --------------------------------------------------------------------------- +// +void CCmPluginBaseEng::EnableLocationL( TBool aEnable ) + { + LOGGER_ENTERFN( "CCmPluginBaseEng::EnableLocationL" ); + + if ( aEnable ) + { + if ( !iLocationRecord ) + { + iLocationRecord = static_cast + (CCDRecordBase::RecordFactoryL(KCDTIdLocationRecord)); + } + } + else + // location is disabled. To be deleted in UpdateL. + // Nothing to do here + { + } + + iLocationEnabled = aEnable; + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::LoadWapRecordL +// --------------------------------------------------------------------------- +// +void CCmPluginBaseEng::LoadWapRecordL() + { + LOGGER_ENTERFN( "CCmPluginBaseEng::LoadWapRecordL" ); + + iPriv->iWapIPBearerRecord = FindWAPRecordL(); + if ( iPriv->iWapIPBearerRecord ) + { + CCDWAPAccessPointRecord *wapApRecord = static_cast + (CCDRecordBase::RecordFactoryL(KCDTIdWAPAccessPointRecord)); + + CleanupStack::PushL( wapApRecord ); + + wapApRecord->SetRecordId( + iPriv->iWapIPBearerRecord->iWAPAccessPointId ); + TRAPD( err, wapApRecord->LoadL( Session() ) ); + if( err == KErrNotFound ) + { + CleanupStack::PopAndDestroy( wapApRecord ); + + wapApRecord = static_cast + (CCDRecordBase::RecordFactoryL(KCDTIdWAPAccessPointRecord)); + } + else + { + CLOG_WRITE( "WAP bearer record found, WAP AP Not??" ); + + User::LeaveIfError( err ); + + CleanupStack::Pop( wapApRecord ); + } + + iPriv->iWapAPRecord = wapApRecord; + } + else + // No WAP record found -> create a new one + { + NewWapRecordL(); + } + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::LoadSeamlessnessRecordL +// --------------------------------------------------------------------------- +// +void CCmPluginBaseEng::LoadSeamlessnessRecordL() + { + LOGGER_ENTERFN( "CCmPluginBaseEng::LoadSeamlessnessRecordL" ); + + iPriv->iMetaDataRecord = FindSeamlessnessRecordL(); + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::UpdateWapRecordL +// --------------------------------------------------------------------------- +// +void CCmPluginBaseEng::UpdateWapRecordL() + { + LOGGER_ENTERFN( "CCmPluginBaseEng::UpdateWapRecordL" ); + + if ( !iPriv->iWapIPBearerRecord ) + // nothing to update + { + return; + } + + // we have the bearer but to make sure that we have WAP_AP, too. + NewWapRecordL(); + + CopyAttributes( iIapRecord, iPriv->iWapAPRecord ); + CopyAttributes( iIapRecord, iPriv->iWapIPBearerRecord ); + + CheckIfNameModifiedL( iPriv->iWapAPRecord ); + CheckIfNameModifiedL( iPriv->iWapIPBearerRecord ); + + if ( !iPriv->iWapAPRecord->RecordId() ) + { + iPriv->iWapAPRecord->SetRecordId( KCDNewRecordRequest ); + iPriv->iWapAPRecord->StoreL( Session() ); + } + else + { + iPriv->iWapAPRecord->ModifyL( Session() ); + } + + if ( !iPriv->iWapIPBearerRecord->RecordId() ) + { + iPriv->iWapIPBearerRecord->iWAPAccessPointId = iPriv->iWapAPRecord->RecordId(); + iPriv->iWapIPBearerRecord->iWAPIAP = iIapId; + + iPriv->iWapIPBearerRecord->SetRecordId( KCDNewRecordRequest ); + iPriv->iWapIPBearerRecord->StoreL( Session() ); + } + else + { + iPriv->iWapIPBearerRecord->ModifyL( Session() ); + } + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::NewWapRecordL +// --------------------------------------------------------------------------- +// +void CCmPluginBaseEng::NewWapRecordL() + { + LOGGER_ENTERFN( "CCmPluginBaseEng::NewWapBearerRecordL" ); + + if ( !iPriv->iWapIPBearerRecord ) + { + iPriv->iWapIPBearerRecord = static_cast + (CCDRecordBase::RecordFactoryL(KCDTIdWAPIPBearerRecord)); + iPriv->iWapIPBearerRecord->iWAPProxyPort = 0; + iPriv->iWapIPBearerRecord->iWAPWSPOption = ECmWapWspOptionConnectionOriented; + iPriv->iWapIPBearerRecord->iWAPSecurity = EFalse; + } + + if ( !iPriv->iWapAPRecord ) + { + iPriv->iWapAPRecord = static_cast + (CCDRecordBase::RecordFactoryL(KCDTIdWAPAccessPointRecord)); + // SMS bearer is not supported by this version + iPriv->iWapAPRecord->iWAPCurrentBearer.SetL( + TPtrC(KCDTypeNameWAPIPBearer) ); + } + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::NewSeamlessnessRecordL +// --------------------------------------------------------------------------- +// +CCDIAPMetadataRecord* CCmPluginBaseEng::NewSeamlessnessRecordL( TBool aSetDef ) + { + LOGGER_ENTERFN( "CCmPluginBaseEng::NewSeamlessnessRecordL" ); + + CCDIAPMetadataRecord* record = new (ELeave) CCDIAPMetadataRecord( + iCmMgr.SeamlessnessTableId() ); + + if( aSetDef ) + { + record->iSeamlessness = ESeamlessnessConfirmFirst; + } + + return record; + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::SetAttribute +// --------------------------------------------------------------------------- +// +void CCmPluginBaseEng::SetAttribute( CCDRecordBase* aRecord, + TUint32 aAttribute, + TBool aSet ) + { + LOGGER_ENTERFN( "CCmPluginBaseEng::SetAttribute" ); + + if ( aSet ) + { + aRecord->SetAttributes( aAttribute ); + } + else + { + aRecord->ClearAttributes( aAttribute ); + } + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::CopyAttributes +// --------------------------------------------------------------------------- +// +void CCmPluginBaseEng::CopyAttributes( CCDRecordBase* aSrcRecord, + CCDRecordBase* aDstRecord ) + { + LOGGER_ENTERFN( "CCmPluginBaseEng::CopyAttributes" ); + + TMDBAttributeFlags attr( aSrcRecord->Attributes() ); + + aDstRecord->SetAttributes( attr ); + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::FindWAPRecordL +// --------------------------------------------------------------------------- +// +CCDWAPIPBearerRecord* CCmPluginBaseEng::FindWAPRecordL() + { + LOGGER_ENTERFN( "CCmPluginBaseEng::FindWAPRecordL" ); + + CMDBRecordSet* wapRS = + new(ELeave) + CMDBRecordSet(KCDTIdWAPIPBearerRecord); + CleanupStack::PushL( wapRS ); + + CCDWAPIPBearerRecord* wapBearerRecord = static_cast + (CCDRecordBase::RecordFactoryL(KCDTIdWAPIPBearerRecord)); + + CleanupStack::PushL( wapBearerRecord ); + + wapBearerRecord->iWAPIAP = iIapId; + wapRS->iRecords.AppendL( wapBearerRecord ); + + CleanupStack::Pop( wapBearerRecord ); + wapBearerRecord = NULL; + + if ( wapRS->FindL(Session()) ) + { + CLOG_WRITE( "WAP bearer record found" ); + + wapBearerRecord = + static_cast(wapRS->iRecords[0]); + + // we take over the ownership of this record + wapRS->iRecords.Remove( 0 ); + } + + CleanupStack::PopAndDestroy( wapRS ); + + return wapBearerRecord; + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::FindSeamlessnessRecordL +// --------------------------------------------------------------------------- +// +CCDIAPMetadataRecord* CCmPluginBaseEng::FindSeamlessnessRecordL() + { + LOGGER_ENTERFN( "CCmPluginBaseEng::FindSeamlessnessRecordL" ); + + CMDBRecordSet* slnRS = + new(ELeave) CMDBRecordSet(iCmMgr.SeamlessnessTableId()); + CleanupStack::PushL( slnRS ); + + CCDIAPMetadataRecord* slnRecord = + new (ELeave) CCDIAPMetadataRecord( iCmMgr.SeamlessnessTableId() ); + + slnRecord->iIAP = IAPRecordElementId(); + slnRS->iRecords.AppendL( slnRecord ); + + slnRecord = NULL; + + if ( slnRS->FindL(Session()) ) + { + CMDBRecordBase* record = slnRS->iRecords[0]; + + slnRecord = NewSeamlessnessRecordL( EFalse ); + slnRecord->SetRecordId( record->RecordId() ); + + // This can leave only in case of OOM. + slnRecord->LoadL( Session() ); + } + else + { + slnRecord = NewSeamlessnessRecordL( ETrue ); + } + + CleanupStack::PopAndDestroy( slnRS ); + + return slnRecord; + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::DoMakeValidNameL +// --------------------------------------------------------------------------- +// +HBufC* CCmPluginBaseEng::DoMakeValidNameL( const TDesC& aName ) + { + LOGGER_ENTERFN( "CCmPluginBaseEng::DoMakeValidNameL" ); + + TBool changed( EFalse ); + HBufC* temp = HBufC::NewLC( KApMaxConnNameLength ); + HBufC* temp2 = HBufC::NewLC( KApMaxConnNameLength ); + + HBufC* corrname = EnsureMaxLengthLC( aName, changed ); + *temp = *corrname; + TInt postfix( 0 ); + TInt pf( 0 ); + TInt i( 0 ); + TBool valid ( EFalse ); + + TPtrC prefix = GetPrefix( *corrname ); + + postfix = GetPostfix( *temp, prefix ); + postfix = -1; + do + { + valid = IsValidNameL( *temp ); + if ( !valid ) + { + changed = ETrue; + postfix++; + // check the length of postfix, check text length accordingly + pf = postfix; + for (i=1; i<10; i++) + { + pf /= 10; + if ( !pf ) + { + break; + } + } + TPtr sgdptr( temp->Des() ); + TPtr sgdptr2( temp2->Des() ); + if ( postfix ) + { + if ( postfix < 10 ) + { + sgdptr2 = prefix.Left( KApMaxConnNameLength - i - 3 ); + } + else + { + sgdptr2 = prefix.Left( KApMaxConnNameLength - i - 2 ); + } + } + else + { + sgdptr2 = prefix.Left( KApMaxConnNameLength ); + } + if ( postfix ) + { + TBuf< KMaxPostfixLength > postfixString; + if ( postfix > 9 ) + { + postfixString.Format( KFormatLargePostfix, postfix ); + AknTextUtils::LanguageSpecificNumberConversion( postfixString ); + } + else + { + postfixString.Format( KFormatPostfix, postfix ); + AknTextUtils::LanguageSpecificNumberConversion( postfixString ); + } + sgdptr.Format( KFormatNameWithPostfix, &sgdptr2, + &postfixString ); + } + else + { + sgdptr.Format( KFormatNoPostfix, &sgdptr2 ); + } + } + } while ( !valid ); + + CleanupStack::PopAndDestroy( corrname ); + CleanupStack::PopAndDestroy( temp2 ); + + if ( changed ) + { + CLOG_WRITE_1( "New name: [%S]", temp ); + CleanupStack::Pop( temp ); + } + else + { + CleanupStack::PopAndDestroy( temp ); + temp = NULL; + } + + return temp; + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::EnsureMaxLengthLC +// --------------------------------------------------------------------------- +// +HBufC* CCmPluginBaseEng::EnsureMaxLengthLC( const TDesC& aName, + TBool& aChanged ) + { + LOGGER_ENTERFN( "CCmPluginBaseEng::EnsureMaxLengthLC" ); + + TInt length = aName.Length(); + + aChanged = EFalse; + + if ( !length ) + { + // Name is required. + User::Leave( KErrArgument ); + } + + HBufC* corrname; + if ( KApMaxConnNameLength < length ) + { // name too long, truncate. + corrname = aName.Left( KApMaxConnNameLength ).AllocLC(); + aChanged = ETrue; + } + else + { + corrname = aName.AllocLC(); + corrname->Des().Trim(); + if ( corrname->Length() == 0 ) + { + User::Leave( KErrArgument ); + } + // comes here only if name is valid + if ( corrname->Length() != aName.Length() ) + { + aChanged = ETrue; + } + } + + return corrname; + } + +// --------------------------------------------------------------------------- +// Given aName in the format or , +// return a pointer to the leading part. +// That is, if there is trailing , +// then that is excluded; if there is no trailing part, then the original +// decriptor is returned. +// Examples: +// - "Foo" returns "Foo"; +// - "Foo 12" returns "Foo 12"; +// - "Foo(12)" returns "Foo"; +// - "Foo 12 (34)" returns "Foo 12 "; +// - "Foo bar" returns "Foo bar"; +// - "Foo " returns "Foo ". +// --------------------------------------------------------------------------- +TPtrC CCmPluginBaseEng::GetPrefix( const TDesC& aName ) + { + LOGGER_ENTERFN( "CCmPluginBaseEng::GetPrefix" ); + + TPtrC prefix = aName; + TInt lastBrace = aName.LocateReverse('('); + if ( lastBrace != KErrNotFound ) + { + // aName looks like "". + // See if is an integer number. + TPtrC num = aName.Right( aName.Length() - lastBrace - 1 ); + TInt val; + TLex lex( num ); + if ( lex.Val( val ) == KErrNone ) + { + // Yes, the trailer is an integer. + prefix.Set( aName.Left( lastBrace ) ); + } + } + return prefix; + } + + +// --------------------------------------------------------------------------- +// If aName is constructed from aPrefix with a postfix, get the numeric +// value of the postfix, e.g: +// - GetPostfix( "Foo (3)", "Foo" ) == 3 +// - GetPostfix( "Foo 23 (45)", "Foo 23" ) == 45 +// If aName is the same as aPrefix, return 0, e.g.: +// - GetPostfix( "Foo", "Foo" ) == 0 +// If aName is not constructed from aPrefix, return -1, e.g.: +// - GetPostfix( "Foobar", "Foo" ) == -1 +// - GetPostfix( "Fo 23 45", "Foo" ) == -1 +// --------------------------------------------------------------------------- +TInt CCmPluginBaseEng::GetPostfix( const TDesC& aName, const TDesC& aPrefix ) + { + LOGGER_ENTERFN( "CCmPluginBaseEng::GetPostfix" ); + TInt postfix( KErrNotFound ); + TInt nameLength = aName.Length(); + TInt prefixLength = aPrefix.Length(); + if ( nameLength >= prefixLength && aName.FindF( aPrefix ) == 0 ) + { + // aName is longer or equal length, and + // aPrefix can be found in the beginning of aName. + if ( nameLength == prefixLength ) + { + // They have the same length; they equal. + postfix = 0; + } + else + { + if ( prefixLength > 0 ) + { + if ( aName[ prefixLength ] == '(' ) + { + // (Now we know that aName is longer than aPrefix.) + // aName looks like "aPrefix". + // See if is an integer number. + TPtrC num = aName.Right( nameLength - prefixLength - 1 ); + TBuf< KApMaxConnNameLength > pf; + pf = num; + AknTextUtils::ConvertDigitsTo( pf, EDigitTypeWestern ); + TInt val; + TLex lex( pf ); + if ( lex.Val( val ) == KErrNone ) + { + // Yes, the trailer is an integer. + if ( val > 0 ) + { + postfix = val; + } + else + { + // signal that it is invalid... + postfix = -1; + } + } + } + } + else + { + postfix = -1; + } + } + } + return postfix; + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::IsValidNameL +// --------------------------------------------------------------------------- +// +TBool CCmPluginBaseEng::IsValidNameL( const TDesC& aNameText ) + { + LOGGER_ENTERFN( "CCmPluginBaseEng::IsValidNameL" ); + + TBool retVal( ETrue ); + + OpenTransactionLC(); + + CMDBRecordSet* iapRS = + new(ELeave) CMDBRecordSet(KCDTIdIAPRecord); + CleanupStack::PushL(iapRS); + + CCDIAPRecord* iapRecord = static_cast + (CCDRecordBase::RecordFactoryL(KCDTIdIAPRecord)); + + CleanupStack::PushL( iapRecord ); + + // Prime record + iapRecord->iRecordName.SetL( aNameText ); + + iapRS->iRecords.AppendL( iapRecord ); + + CleanupStack::Pop( iapRecord ); + + iapRecord = NULL; + + if ( iapRS->FindL(Session()) ) + { + if ( iIapId ) + // this is not a new CM + { + for ( TInt i = 0; i < iapRS->iRecords.Count(); ++i ) + { + if ( iapRS->iRecords[i]->RecordId() != iIapId ) + // duplication because it's not our name + { + retVal = EFalse; + break; + } + } + } + else + // new CM -> any occurence is a duplication + { + retVal = EFalse; + } + } + + CleanupStack::PopAndDestroy( iapRS ); + + RollbackTransaction(); + + return retVal; + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::EscapeTextLC +// --------------------------------------------------------------------------- +// +HBufC* CCmPluginBaseEng::EscapeTextLC( const TDesC& aLiteral ) + { + LOGGER_ENTERFN( "CCmPluginBaseEng::EscapeTextLC" ); + + TInt l( aLiteral.Length() ); + //> 2*, to ensure correct esc. even if ALL chars are quotes... + HBufC* retbuf = HBufC::NewLC( 2*l ); + TPtr ret = retbuf->Des(); + TUint quote( '\'' ); // TChar gives warnings in THUMB & ARMI + TInt i( 0 ); + + for ( i=0; iiNamingMethod == ENamingNothing ) + { + iIapRecord->iRecordName.SetL( aName ); + } + else if ( iPriv->iNamingMethod == ENamingUnique ) + { + HBufC* newName = DoMakeValidNameL( aName ); + + if ( newName ) + // name converted to unique + { + CleanupStack::PushL( newName ); + iIapRecord->iRecordName.SetL( *newName ); + CleanupStack::PopAndDestroy( newName ); + } + else + { + iIapRecord->iRecordName.SetL( aName ); + } + } + else if ( iPriv->iNamingMethod == ENamingNotAccept ) + { + if ( IsValidNameL( aName ) ) + { + iIapRecord->iRecordName.SetL( aName ); + } + else + { + User::Leave( KErrArgument ); + } + } + else + { + User::Leave( KErrCorrupt ); + } + + CLOG_WRITE_1( "Finale name: [%S]", &FIELD_TO_TDESC(iIapRecord->iRecordName) ); + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::AddConverstionTableL +// --------------------------------------------------------------------------- +// +EXPORT_C void CCmPluginBaseEng::AddConverstionTableL( CCDRecordBase* *aRecord, + TBool* aEnabled, + const TCmAttribConvTable* aConvTable ) + { + LOGGER_ENTERFN( "CCmPluginBaseEng::AddConverstionTableL" ); + TCmAttrConvArrayItem* item = new (ELeave) TCmAttrConvArrayItem; + + item->iRecord = aRecord; + item->iEnabled = aEnabled; + item->iConvTable = aConvTable; + + iPriv->iConvTblArray->AppendL( item ); + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::AddCommonConversionTableL +// --------------------------------------------------------------------------- +// +EXPORT_C void CCmPluginBaseEng::AddCommonConversionTableL( + const TCmCommonAttrConvArrayItem* aConvTable ) + { + LOGGER_ENTERFN( "CCmPluginBaseEng::AddCommonConversionTableL" ); + + User::LeaveIfError( iPriv->iCommonConvTblArray.Append( aConvTable ) ); + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::RemoveConversionTable +// --------------------------------------------------------------------------- +// +EXPORT_C void CCmPluginBaseEng::RemoveConversionTable( + const TCmAttribConvTable* aConvTable ) + { + LOGGER_ENTERFN( "CCmPluginBaseEng::RemoveConversionTable" ); + + for ( TInt i = 0; i < iPriv->iConvTblArray->Count(); ++i ) + { + if ( (*iPriv->iConvTblArray)[i]->iConvTable == aConvTable ) + { + delete (*iPriv->iConvTblArray)[i]; + iPriv->iConvTblArray->Delete( i ); + } + } + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::RemoveCommonConversionTable +// --------------------------------------------------------------------------- +// +EXPORT_C void CCmPluginBaseEng::RemoveCommonConversionTable( + const TCmCommonAttrConvArrayItem* aConvTable ) + { + LOGGER_ENTERFN( "CCmPluginBaseEng::RemoveCommonConversionTable" ); + + // When calling Remove(), it's safer to loop starting from end. + for ( TInt i = iPriv->iCommonConvTblArray.Count()-1; i >= 0; i-- ) + { + if ( iPriv->iCommonConvTblArray[i] == aConvTable ) + { + iPriv->iCommonConvTblArray.Remove( i ); + } + } + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::FindFieldL +// --------------------------------------------------------------------------- +// +TValidationFunctionL CCmPluginBaseEng::FindFieldL( TUint32 aAttribute, + TCMFieldTypes aType, + CMDBElement* &aElement ) const + { + LOGGER_ENTERFN( "CCmPluginBaseEng::FindFieldL" ); + + TValidationFunctionL func = NULL; + const TCmAttrConvArrayItem* foundItem = ConversionTable( aAttribute ); + + aElement = NULL; + + if( !foundItem ) + { + User::Leave( KErrNotSupported ); + } + + if ( foundItem->iEnabled ) + { + if ( !(*foundItem->iEnabled) ) + { + User::Leave( KErrNotSupported ); + } + } + + if ( !(*foundItem->iRecord) ) + { + User::Leave( KErrNotSupported ); + } + + TInt index( 0 ); + CMDBElement& field = FieldByAttributeL( foundItem, aAttribute, index ); + switch ( field.Type() ) + { + case EText: + case EMedText: + case ELongText: + { + if ( aType == ECmText ) + { + aElement = &field; + } + } + break; + + case EDesC8: + { + if ( aType == ECmText8 ) + { + aElement = &field; + } + } + break; + + case EUint32: + case EInt: + case EBool: + { + if ( aType == ECmInt || + aType == ECmBool ) + { + aElement = &field; + } + } + break; + + default: + { + User::Leave( KErrArgument ); + } + break; + } + + if( aElement ) + { + func = foundItem->iConvTable[index].iValidFuncL; + } + else + { + User::Leave( KErrNotSupported ); + } + + return func; + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::Reset +// --------------------------------------------------------------------------- +// +EXPORT_C void CCmPluginBaseEng::Reset() + { + LOGGER_ENTERFN( "CCmPluginBaseEng::Reset" ); + + iIapId = 0; + + delete iIapRecord; iIapRecord = NULL; + delete iProxyRecord; iProxyRecord = NULL; + delete iServiceRecord; iServiceRecord = NULL; + delete iChargeCardRecord; iChargeCardRecord = NULL; + delete iNetworkRecord; iNetworkRecord = NULL; + delete iLocationRecord; iLocationRecord = NULL; + if ( iPriv ) + { + iPriv->iLoadResult = KErrNone; + delete iPriv->iWapAPRecord; iPriv->iWapAPRecord = NULL; + delete iPriv->iWapIPBearerRecord; iPriv->iWapIPBearerRecord = NULL; + delete iPriv->iMetaDataRecord; iPriv->iMetaDataRecord = NULL; + } + + iChargeCardEnabled = EFalse; + iLocationEnabled = EFalse; + } + + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::CheckIfAlreadyConnected +// --------------------------------------------------------------------------- +EXPORT_C TBool CCmPluginBaseEng::CheckIfAlreadyConnected() const + { + LOGGER_ENTERFN( "CCmPluginBaseEng::CheckIfAlreadyConnected" ); + + TBool retVal( EFalse ); + RSocketServ serv; + RConnection connection; + TUint count; + + if ( serv.Connect() == KErrNone ) + { + if ( connection.Open( serv, KAfInet ) == KErrNone ) + { + if ( connection.EnumerateConnections( count ) == KErrNone ) + { + TPckgBuf connInfo; + + for ( TUint32 i = 1; i <= count; ++i ) + { + connection.GetConnectionInfo( i, connInfo ); + + if ( connInfo().iIapId == iIapId ) + { + CLOG_WRITE( "Found connection" ); + retVal = ETrue; + break; + } + } + } + + connection.Close(); + } + + serv.Close(); + } + + return retVal; + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::CheckIfNameModifiedL +// --------------------------------------------------------------------------- +EXPORT_C void + CCmPluginBaseEng::CheckIfNameModifiedL( CCDRecordBase* aRecord ) const + { + LOGGER_ENTERFN( "CCmPluginBaseEng::CheckIfNameModifiedL" ); + + if ( !TPtrC(iIapRecord->iRecordName).CompareF( TPtrC(aRecord->iRecordName)) ) + // names matche + { + return; + } + + aRecord->iRecordName.SetL( TPtrC(iIapRecord->iRecordName) ); + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::IAPRecordElementId +// --------------------------------------------------------------------------- +TMDBElementId CCmPluginBaseEng::IAPRecordElementId() const + { + LOGGER_ENTERFN( "CCmPluginBaseEng::IAPRecordElementId" ); + + return ( KCDMaskShowField & iIapRecord->ElementId() ); + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::IsProtected +// --------------------------------------------------------------------------- +TBool CCmPluginBaseEng::IsProtected() const + { + LOGGER_ENTERFN( "CCmPluginBaseEng::IsProtected" ); + + return ( iIapRecord->Attributes() & ECDProtectedWrite ); + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::GetLocationIdL +// --------------------------------------------------------------------------- +TUint32 CCmPluginBaseEng::GetLocationIdL() const + { + LOGGER_ENTERFN( "CCmPluginBaseEng::GetLocationIdL" ); + + TUint32 locId( 0 ); + CMDBRecordSet* locRS = + new(ELeave) CMDBRecordSet(KCDTIdLocationRecord); + CleanupStack::PushL( locRS ); + + CCDLocationRecord* locRecord = static_cast + (CCDRecordBase::RecordFactoryL(KCDTIdLocationRecord)); + + CleanupStack::PushL( locRecord ); + locRecord->iRecordName.SetL( KLocationName ); + locRS->iRecords.AppendL( locRecord ); + CleanupStack::Pop( locRecord ); + + if ( locRS->FindL(Session()) ) + { + locRecord = static_cast(locRS->iRecords[0]); + + locId = locRecord->RecordId(); + } + else + { + CLOG_WRITE( "Loc id not found" ); + User::Leave( KErrNotFound ); + } + + CleanupStack::PopAndDestroy( locRS ); + + return locId; + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::CheckForCommonAttribute +// --------------------------------------------------------------------------- +TUint32 + CCmPluginBaseEng::CheckForCommonAttribute( const TUint32 aAttribute ) const + { + LOGGER_ENTERFN( "CCmPluginBaseEng::CheckForCommonAttribute" ); + + TUint32 convAttr( aAttribute ); + + if ( iPriv->iCommonConvTblArray.Count() && + aAttribute > ECmCommonAttributesStart && + aAttribute < ECmCommonAttributesEnd ) + { + for ( TInt i = 0; i < iPriv->iCommonConvTblArray.Count(); ++i ) + { + const TCmCommonAttrConvArrayItem* convArray = + iPriv->iCommonConvTblArray[i]; + for ( TInt item = 0; convArray[item].iCommonAttribId; ++item ) + { + if ( convArray[item].iCommonAttribId == aAttribute ) + { + return convArray[item].iAttribId; + } + } + } + } + + return convAttr; + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::CommonAttribute +// --------------------------------------------------------------------------- +/*TUint32 CCmPluginBaseEng::CommonAttributeL( const TUint32 aAttribute ) const + { + LOGGER_ENTERFN( "CCmPluginBaseEng::CommonAttribute" ); + + if ( iPriv->iCommonConvTblArray.Count() ) + { + for ( TInt i = 0; i < iPriv->iCommonConvTblArray.Count(); ++i ) + { + const TCmCommonAttrConvArrayItem* convArray = + iPriv->iCommonConvTblArray[i]; + for ( TInt item = 0; convArray[item].iCommonAttribId; ++item ) + { + if ( convArray[item].iAttribId == aAttribute ) + { + return convArray[item].iCommonAttribId; + } + } + } + } + + User::Leave( KErrArgument ); + + return 0; + }*/ + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::FeatureSupported +// --------------------------------------------------------------------------- +EXPORT_C TBool CCmPluginBaseEng::FeatureSupported( TInt aFeature ) + { +#ifdef _IPV6_DISABLED + if( aFeature == KFeatureIdIPv6 ) + { + return EFalse; + } +#endif + return CCmManagerImpl::FeatureSupported( aFeature ); + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::GlobalBearerPriority +// --------------------------------------------------------------------------- +EXPORT_C TInt + CCmPluginBaseEng::GlobalBearerPriority( const TDesC& aServiceType ) const + { + LOGGER_ENTERFN( "CCmPluginBaseEng::GlobalBearerPriority" ); + + return iCmMgr.GlobalBearerPriority( EFalse, aServiceType ); + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::GlobalUiBearerPriority +// --------------------------------------------------------------------------- +EXPORT_C TInt + CCmPluginBaseEng::GlobalUiBearerPriority( const TDesC& aServiceType ) const + { + LOGGER_ENTERFN( "CCmPluginBaseEng::GlobalUiBearerPriority" ); + + return iCmMgr.GlobalBearerPriority( ETrue, aServiceType ); + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::SetProxyServerNameL +// --------------------------------------------------------------------------- +TBool CCmPluginBaseEng::SetProxyServerNameL( const TDesC& aProxyServer ) + { + LOGGER_ENTERFN( "CCmPluginBaseEng::SetProxyServerNameL" ); + + iProxyRecord->iServerName.SetL( aProxyServer ); + if( !aProxyServer.Length() ) + { + iProxyRecord->iPortNumber = 0; + iProxyRecord->iUseProxyServer = EFalse; + } + else + { + iProxyRecord->iUseProxyServer = ETrue; + } + + return ETrue; + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::ConvTableItemL +// --------------------------------------------------------------------------- +EXPORT_C const TCmAttribConvTable* + CCmPluginBaseEng::ConvTableItem( TUint32 aAttribute ) + { + LOGGER_ENTERFN( "CCmPluginBaseEng::ConvTableItem" ); + + TInt i; + TCmAttrConvArrayItem* foundItem = ConversionTable( aAttribute ); + + if( foundItem ) + { + // From 2nd item, because the first one is for the range. + for ( i = 1; foundItem->iConvTable[i].iAttribId; ++i ) + { + if ( foundItem->iConvTable[i].iAttribId == aAttribute ) + { + return &foundItem->iConvTable[i]; + } + } + } + else + { + // I know that this is a not nice solution, but + // I couldn't find any more inteligent way of adding + // ECmBearerSettingName to the array. + const TCmAttribConvTable* item = SUiTable; + + // This is a where use + for ( i = 0; item[i].iAttribId; ++i ) + { + if( item[i].iAttribId == aAttribute ) + { + return &item[i]; + } + } + } + + return NULL; + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::ConversionTable +// --------------------------------------------------------------------------- +TCmAttrConvArrayItem* + CCmPluginBaseEng::ConversionTable( TUint32 aAttribute ) const + { + LOGGER_ENTERFN( "CCmPluginBaseEng::ConversionTable" ); + + TCmAttrConvArrayItem* foundItem = NULL; + TInt i; + + for ( i = 0; i < iPriv->iConvTblArray->Count(); ++i ) + { + TCmAttrConvArrayItem* item = (*iPriv->iConvTblArray)[i]; + + if ( item->iConvTable[0].iAttribId <= aAttribute && + item->iConvTable[0].iCommsDatId >= aAttribute ) + { + foundItem = item; + break; + } + } + + return foundItem; + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::FieldByAttributeL +// --------------------------------------------------------------------------- +CMDBElement& CCmPluginBaseEng::FieldByAttributeL( + const TCmAttrConvArrayItem* aItem, + const TUint32 aAttribute, + TInt& aIndex ) const + { + LOGGER_ENTERFN( "CCmPluginBaseEng::FieldByAttributeL" ); + + // From 2nd item, because the first one is for the range. + for ( aIndex = 1; aItem->iConvTable[aIndex].iAttribId; ++aIndex ) + { + if ( aItem->iConvTable[aIndex].iAttribId == aAttribute ) + { + return *(*aItem->iRecord)->GetFieldByIdL( + aItem->iConvTable[aIndex].iCommsDatId ); + } + } + + User::Leave( KErrNotFound ); + // Dead code + return *(CMDBElement*)1; + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::SetDNSServerAddressL +// --------------------------------------------------------------------------- +// +EXPORT_C void CCmPluginBaseEng::SetDNSServerAddressL( TUint32 aSrv1Attr, + const TDesC& aSrv1, + TUint32 aSrv2Attr, + const TDesC& aSrv2, + TUint32 aAddrFromSrvAttr, + TBool aIPv6 ) + { + LOGGER_ENTERFN( "CCmPluginBaseEng::SetDNSServerAddressL" ); + + TBool undef1; + TBool undef2; + TPtrC dynamic; + + if( aIPv6 ) + // IPv6 + { + undef1 = ClassifyIPv6Address( aSrv1 ) == EIPv6Unspecified; + undef2 = ClassifyIPv6Address( aSrv2 ) == EIPv6Unspecified; + + dynamic.Set( KDynamicIpv6Address ); + } + else + { + undef1 = IsUnspecifiedIPv4Address( aSrv1 ); + undef2 = IsUnspecifiedIPv4Address( aSrv2 ); + + dynamic.Set( KUnspecifiedIPv4 ); + } + + if( undef1 ) + { + SetStringAttributeL( aSrv1Attr, aSrv2 ); + SetStringAttributeL( aSrv2Attr, dynamic ); + + SetBoolAttributeL( aAddrFromSrvAttr, undef2 ); + } + else + { + SetStringAttributeL( aSrv1Attr, aSrv1 ); + SetStringAttributeL( aSrv2Attr, aSrv2 ); + + SetBoolAttributeL( aAddrFromSrvAttr, EFalse ); + } + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::CheckDNSServerAddressL +// --------------------------------------------------------------------------- +// +EXPORT_C void CCmPluginBaseEng::CheckDNSServerAddressL( TBool aIPv6, + CMDBField& aDNS1, + CMDBField& aDNS2, + CMDBField& /*aDNSFromServer*/ ) + { + LOGGER_ENTERFN( "CCmPluginBaseEng::CheckDNSServerAddressL" ); + + // aDNSFromServer is commented out because the API must not set this + // field any more. It is only set from the UI + if( !(aDNS1.ElementId() & KCDChangedFlag) && + !(aDNS2.ElementId() & KCDChangedFlag) ) + // No change + { + return; + } + + if( aIPv6 ) + { + if( ClassifyIPv6Address( aDNS1 ) == EIPv6Unspecified ) + { + if( ClassifyIPv6Address( aDNS2 ) != EIPv6Unspecified ) + { + aDNS1.SetL( aDNS2 ); + aDNS2.SetL( KDynamicIpv6Address ); + } + } + } + else // IPv4 + { + if( IsUnspecifiedIPv4Address( aDNS1 ) ) + { + if( !IsUnspecifiedIPv4Address( aDNS2 ) ) + { + aDNS1.SetL( aDNS2 ); + aDNS2.SetL( KUnspecifiedIPv4 ); + } + } + } + } + + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::CheckSpaceBelowCriticalLevelL +// --------------------------------------------------------------------------- +// +TBool CCmPluginBaseEng::CheckSpaceBelowCriticalLevelL() const + { + LOGGER_ENTERFN( "CCmPluginBaseEng::CheckSpaceBelowCriticalLevelL" ); + + // OOD handling. If disk space is low user is notified. + RFs fs; + User::LeaveIfError( fs.Connect() ); + CleanupClosePushL( fs ); + + // Checks the FFS space "after" addition + TBool belowCL = SysUtil::FFSSpaceBelowCriticalLevelL + ( &fs, KEstimatedOverhead ); + + CleanupStack::PopAndDestroy(); // fs + + if( belowCL ) + { + // Raise a dialog to notify the user. + TCmCommonUi::ShowMemoryFullConfirmationQueryL(); + // It must leave because it is the only way to notify the caller about + // the operation failed. (Its caller does not return indicator.) + // KLeaveWithoutAlert means no more dialog will raise + User::Leave( KLeaveWithoutAlert ); + } + + // Return value keept to have a suitable API + return belowCL; + + } + +// ----------------------------------------------------------------------------- +// CCmPluginBaseEng::IncrementRefCounter +// ----------------------------------------------------------------------------- +void CCmPluginBaseEng::IncrementRefCounter() + { + LOGGER_ENTERFN( "CCmPluginBaseEng::IncrementRefCounter" ); + + iRefCounter++; + } +// ----------------------------------------------------------------------------- +// CCmPluginBaseEng::DecrementRefCounter +// ----------------------------------------------------------------------------- +void CCmPluginBaseEng::DecrementRefCounter() + { + LOGGER_ENTERFN( "CCmPluginBaseEng::DecrementRefCounter" ); + + iRefCounter--; + } +// ----------------------------------------------------------------------------- +// CCmPluginBaseEng::GetRefCounter +// ----------------------------------------------------------------------------- +TInt CCmPluginBaseEng::GetRefCounter() + { + LOGGER_ENTERFN( "CCmPluginBaseEng::GetRefCounter" ); + + return iRefCounter; + } + +// ----------------------------------------------------------------------------- +// CCmPluginBaseEng::IdIsValid +// ----------------------------------------------------------------------------- +TBool CCmPluginBaseEng::IdIsValid() + { + LOGGER_ENTERFN( "CCmPluginBaseEng::IdIsValid" ); + + return iIdIsValid; + } + + +// ----------------------------------------------------------------------------- +// CCmPluginBaseEng::IdIsValid +// ----------------------------------------------------------------------------- +void CCmPluginBaseEng::SetIdValidity(TBool validity) + { + LOGGER_ENTERFN( "CCmPluginBaseEng::SetIdValidity" ); + + iIdIsValid = validity; + } + + +// ----------------------------------------------------------------------------- +// CCmPluginBaseEng::GetRefCounter +// ----------------------------------------------------------------------------- +void CCmPluginBaseEng::GenericStringWriterL( const TUint32 aAttribute, + const TDesC16& aValue ) + { + LOGGER_ENTERFN( "CCmPluginBaseEng::GenericStringWriterL" ); + + TUint32 attribute = CheckForCommonAttribute( aAttribute ); + CMDBField* field; + + TValidationFunctionL func = + FindFieldL( attribute, ECmText, (CMDBElement*&)field ); + + if( func ) + { + func( this, attribute, (const TAny*)&aValue ); + } + + field->SetL( aValue ); + } + +// --------------------------------------------------------------------------- +// CCmPluginBaseEng::MappedCommonAttribute +// --------------------------------------------------------------------------- +TUint32 + CCmPluginBaseEng::MappedCommonAttribute( const TUint32 aAttribute ) const + { + LOGGER_ENTERFN( "CCmPluginBaseEng::MappedCommonAttribute" ); + + TUint32 convAttr( aAttribute ); + + if ( iPriv->iCommonConvTblArray.Count() ) + { + for ( TInt i = 0; i < iPriv->iCommonConvTblArray.Count(); ++i ) + { + const TCmCommonAttrConvArrayItem* convArray = + iPriv->iCommonConvTblArray[i]; + for ( TInt item = 0; convArray[item].iCommonAttribId; ++item ) + { + if ( convArray[item].iAttribId == aAttribute ) + { + return convArray[item].iCommonAttribId; + } + } + } + } + + return convAttr; + } +//----------------------------------------------------------------------------- +// CCmPluginBaseEng::ParentDestination +// ----------------------------------------------------------------------------- +EXPORT_C CCmDestinationImpl* CCmPluginBaseEng::ParentDestination() const + { + LOGGER_ENTERFN( "CCmPluginBaseEng::ParentDestination" ); + + if (iParentDest) + { + CCmDestinationImpl* parentDest = NULL; + TRAPD( err, parentDest = iCmMgr.DestinationL( iParentDest ) ); + if ( !err ) + { + return parentDest; + } + } + + return NULL; + } + +//----------------------------------------------------------------------------- +// CCmPluginBaseEng::GetAdditionalUids +// ----------------------------------------------------------------------------- +EXPORT_C void CCmPluginBaseEng::GetAdditionalUids( RArray& /*aIapIds*/ ) + { + LOGGER_ENTERFN( "CCmPluginBaseEng::GetAdditionalUids" ); + } + +//----------------------------------------------------------------------------- +// CCmPluginBaseEng::SetPreDefinedId +// ----------------------------------------------------------------------------- +EXPORT_C void CCmPluginBaseEng::SetPreDefinedId( const TUint32 aPreDefId ) + { + LOGGER_ENTERFN( "CCmPluginBaseEng::SetPreDefinedId" ); + + iPreDefIapId = aPreDefId; + } +