--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/deviceupdatesui/omadmadapters/globalwlansettings/src/globalwlanadapter.cpp Tue Jul 13 03:44:34 2010 +0530
@@ -0,0 +1,2998 @@
+/*
+* Copyright (c) 2008 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: Global WLAN settings Adapter
+*
+*/
+
+
+
+#include "globalwlanadapter.h"
+#include "nsmldebug.h"
+#include <implementationproxy.h> // For TImplementationProxy definition
+#include <commdb.h>
+#include <WlanCdbCols.h>
+#include <utf.h>
+#include <cdbstore.h>
+#include <cdbcols.h>
+#include <f32file.h>
+#include <e32const.h>
+#include <s32strm.h>
+#include <e32base.h>
+#include <sysutil.h>
+#include <e32cmn.h>
+#include <featmgr.h>
+
+#include <centralrepository.h>
+#include <commsdattypesv1_1.h>
+
+
+#ifndef __WINS__
+// This lowers the unnecessary compiler warning (armv5) to remark.
+// "Warning: #174-D: expression has no effect..." is caused by
+// DBG_ARGS8 macro in no-debug builds.
+#pragma diag_remark 174
+#endif
+
+
+//------------------------------------------------------------------------------
+//
+//------------------------------------------------------------------------------
+const TImplementationProxy ImplementationTable[] =
+ {
+ IMPLEMENTATION_PROXY_ENTRY(0x1315DBE, CGlobalWLANAdapter::NewL)
+ };
+
+//------------------------------------------------------------------------------
+// TImplementationProxy* ImplementationGroupProxy()
+//------------------------------------------------------------------------------
+EXPORT_C const TImplementationProxy* ImplementationGroupProxy( TInt& aTableCount )
+ {
+ _DBG_FILE("ImplementationGroupProxy() for CGlobalWLANAdapter: begin");
+
+ aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);
+
+ _DBG_FILE("ImplementationGroupProxy() for CGlobalWLANAdapter: end");
+ return ImplementationTable;
+ }
+
+
+//-----------------------------------------------------------------------------
+// CGlobalWLANAdapter* CGlobalWLANAdapter::NewL( )
+//-----------------------------------------------------------------------------
+CGlobalWLANAdapter* CGlobalWLANAdapter::NewL( MSmlDmCallback* aDmCallback )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::NewL(): begin");
+
+ CGlobalWLANAdapter* self = NewLC( aDmCallback );
+ CleanupStack::Pop( self );
+
+ _DBG_FILE("CGlobalWLANAdapter::NewL(): end");
+ return self;
+ }
+
+//-----------------------------------------------------------------------------
+// CGlobalWLANAdapter* CGlobalWLANAdapter::NewLC( )
+//-----------------------------------------------------------------------------
+CGlobalWLANAdapter* CGlobalWLANAdapter::NewLC( MSmlDmCallback* aDmCallback )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::NewLC(): begin");
+
+ CGlobalWLANAdapter* self = new(ELeave) CGlobalWLANAdapter(aDmCallback);
+ CleanupStack::PushL( self );
+
+ self->iCallBack = aDmCallback;
+ _DBG_FILE("CGlobalWLANAdapter::NewLC(): call constructL");
+ self->ConstructL( );
+
+ _DBG_FILE("CGlobalWLANAdapter::NewLC(): end");
+ return self;
+ }
+
+//-----------------------------------------------------------------------------
+// void CGlobalWLAdapter::ConstructL( )
+// Second phase constructor
+//-----------------------------------------------------------------------------
+void CGlobalWLANAdapter::ConstructL( )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::ConstructL(): begin");
+
+ // checks if Wlan feature is supported
+ FeatureManager::InitializeLibL();
+ iWlanSupported = FeatureManager::FeatureSupported( KFeatureIdProtocolWlan );
+ FeatureManager::UnInitializeLib();
+
+ iWriteSettings = new(ELeave) TGlobalSettings;
+ iReadSettings = new(ELeave) TGlobalSettings;
+ iReadStatuses = new(ELeave) TStatusResult;
+ iWriteStatuses = new(ELeave) TStatusResult;
+
+ // set "present" variables to false, since symbian inits thems as true
+ InitMemberVariables();
+
+ _DBG_FILE("CGlobalWLANAdapter::ConstructL(): end");
+ }
+
+//-----------------------------------------------------------------------------
+// CGlobalWLANAdapter::CGlobalWLANAdapter( )
+// Constructor
+//-----------------------------------------------------------------------------
+CGlobalWLANAdapter::CGlobalWLANAdapter( TAny* aEcomArguments )
+ : CSmlDmAdapter(aEcomArguments)
+ {
+ _DBG_FILE("CGlobalWLANAdapter::CGlobalWLANAdapter(): begin");
+ _DBG_FILE("CGlobalWLANAdapter::CGlobalWLANAdapter(): end");
+ }
+
+//-----------------------------------------------------------------------------
+// CGlobalWLANAdapter::~CGlobalWLANAdapter( )
+// Destructor
+//-----------------------------------------------------------------------------
+CGlobalWLANAdapter::~CGlobalWLANAdapter( )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::~CGlobalWLANAdapter(): begin");
+
+ delete iWriteSettings;
+ delete iReadSettings;
+ delete iReadStatuses;
+ delete iWriteStatuses;
+
+ _DBG_FILE("CGlobalWLANAdapter::~CGlobalWLANAdapter(): end");
+ }
+
+
+//-----------------------------------------------------------------------------
+// CGlobalWLANAdapter* CGlobalWLANAdapter::DDFVersionL( CBufBase& aDDFVersion )
+//-----------------------------------------------------------------------------
+void CGlobalWLANAdapter::DDFVersionL( CBufBase& aDDFVersion )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::DDFVersionL(): begin");
+
+ aDDFVersion.InsertL( 0, KNSmGlobalWlanAdapterDDFversion );
+
+ _DBG_FILE("CGlobalWLANAdapter::DDFVersionL(): end");
+ }
+
+//-----------------------------------------------------------------------------
+// CGlobalWLANAdapter* CGlobalWLANAdapter::DDFStructureL( MSmlDmDDFObject& aDDF )
+//-----------------------------------------------------------------------------
+void CGlobalWLANAdapter::DDFStructureL( MSmlDmDDFObject& aDDF )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::DDFStructureL(): begin");
+ if( !iWlanSupported )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::DDFStructureL(): WLAN not supported.");
+ return;
+ }
+//
+// Set Get, add and replace as acceptable operations
+//
+
+ TSmlDmAccessTypes accessTypesGetAddReplace;
+ accessTypesGetAddReplace.SetAdd();
+ accessTypesGetAddReplace.SetGet();
+ accessTypesGetAddReplace.SetReplace();
+
+ //WLAN
+ MSmlDmDDFObject& rootWLan = aDDF.AddChildObjectL( KNSmlWLan );
+ FillNodeInfoL( rootWLan,
+ accessTypesGetAddReplace,
+ MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::ENode,
+ KNSmlEmpty );
+
+ //WLAN/InternetConnectivityTest
+ MSmlDmDDFObject& internetConnectivityTest = rootWLan.AddChildObjectL( KNSmlWLanInternetConnectivityTest );
+ FillNodeInfoL( internetConnectivityTest,
+ accessTypesGetAddReplace,
+ MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EInt,
+ KNSmlEmpty );
+
+ //WLAN/UseDefaultSettings
+ MSmlDmDDFObject& useDefaultSettings = rootWLan.AddChildObjectL( KNSmlWLanUseDefaultSettings );
+ FillNodeInfoL( useDefaultSettings,
+ accessTypesGetAddReplace,
+ MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EBool,
+ KNSmlEmpty );
+
+ //WLAN/LongRetryLimit
+ MSmlDmDDFObject& longRetryLimit = rootWLan.AddChildObjectL( KNSmlWLanLongRetryLimit );
+ FillNodeInfoL( longRetryLimit,
+ accessTypesGetAddReplace,
+ MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EInt,
+ KNSmlEmpty );
+
+ //WLAN/ShortRetryLimit
+ MSmlDmDDFObject& shortRetryLimit = rootWLan.AddChildObjectL( KNSmlWLanShortRetryLimit );
+ FillNodeInfoL( shortRetryLimit,
+ accessTypesGetAddReplace,
+ MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EInt,
+ KNSmlEmpty );
+
+
+ //WLAN/RTSThreshold
+ MSmlDmDDFObject& RTSThreshold = rootWLan.AddChildObjectL( KNSmlWLanRTSThreshold );
+ FillNodeInfoL( RTSThreshold,
+ accessTypesGetAddReplace,
+ MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EInt,
+ KNSmlEmpty );
+
+ //WLAN/TXPowerLevel
+ MSmlDmDDFObject& TXPowerLevel = rootWLan.AddChildObjectL( KNSmlWLanTXPowerLevel );
+ FillNodeInfoL( TXPowerLevel,
+ accessTypesGetAddReplace,
+ MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EInt,
+ KNSmlEmpty );
+
+ //WLAN/PowerSaving
+ MSmlDmDDFObject& powerSaving = rootWLan.AddChildObjectL( KNSmlWLanPowerSaving );
+ FillNodeInfoL( powerSaving,
+ accessTypesGetAddReplace,
+ MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EBool,
+ KNSmlEmpty );
+
+ //WLAN/BackgroundScanInterval
+ MSmlDmDDFObject& backgroundScanInterval = rootWLan.AddChildObjectL( KNSmlWLanBackgroundScanInterval );
+ FillNodeInfoL( backgroundScanInterval,
+ accessTypesGetAddReplace,
+ MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EInt,
+ KNSmlEmpty );
+
+ //WLAN/ScanRate
+ MSmlDmDDFObject& scanRate = rootWLan.AddChildObjectL( KNSmlWLanScanRate );
+ FillNodeInfoL( scanRate,
+ accessTypesGetAddReplace,
+ MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EInt,
+ KNSmlEmpty );
+
+ //WLAN/RCPITrigger
+ MSmlDmDDFObject& RCPITrigger = rootWLan.AddChildObjectL( KNSmlWLanRCPITrigger );
+ FillNodeInfoL( RCPITrigger,
+ accessTypesGetAddReplace,
+ MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EInt,
+ KNSmlEmpty );
+
+ //WLAN/MinActiveChannelTime
+ MSmlDmDDFObject& minActiveChannelTime = rootWLan.AddChildObjectL( KNSmlWLanMinActiveChannelTime );
+ FillNodeInfoL( minActiveChannelTime,
+ accessTypesGetAddReplace,
+ MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EInt,
+ KNSmlEmpty );
+
+ //WLAN/MaxActiveChannelTime
+ MSmlDmDDFObject& maxActiveChannelTime = rootWLan.AddChildObjectL( KNSmlWLanMaxActiveChannelTime );
+ FillNodeInfoL( maxActiveChannelTime,
+ accessTypesGetAddReplace,
+ MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EInt,
+ KNSmlEmpty );
+
+ //WLAN/MaxTxMSDULifeTime
+ MSmlDmDDFObject& maxTxMSDULifeTime = rootWLan.AddChildObjectL( KNSmlWLanMaxTxMSDULifeTime );
+ FillNodeInfoL( maxTxMSDULifeTime,
+ accessTypesGetAddReplace,
+ MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EInt,
+ KNSmlEmpty );
+
+ //WLAN/ScanExpirationTimer
+ MSmlDmDDFObject& scanExpirationTimer = rootWLan.AddChildObjectL( KNSmlWLanScanExpirationTimer );
+ FillNodeInfoL( scanExpirationTimer,
+ accessTypesGetAddReplace,
+ MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EInt,
+ KNSmlEmpty );
+
+ //WLAN/UnloadDriverTimer
+ MSmlDmDDFObject& unloadDriverTimer = rootWLan.AddChildObjectL( KNSmlWLanUnloadDriverTimer );
+ FillNodeInfoL( unloadDriverTimer,
+ accessTypesGetAddReplace,
+ MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EInt,
+ KNSmlEmpty );
+
+ //WLAN/RoamTimer
+ MSmlDmDDFObject& roamTimer = rootWLan.AddChildObjectL( KNSmlWLanRoamTimer );
+ FillNodeInfoL( roamTimer,
+ accessTypesGetAddReplace,
+ MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EInt,
+ KNSmlEmpty );
+
+ //WLAN/KNSmlWLanRCPIDifference
+ MSmlDmDDFObject& RCPIDifference = rootWLan.AddChildObjectL( KNSmlWLanRCPIDifference );
+ FillNodeInfoL( RCPIDifference,
+ accessTypesGetAddReplace,
+ MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EInt,
+ KNSmlEmpty );
+
+ //WLAN/ConnRegainTimer
+ MSmlDmDDFObject& connRegainTimer = rootWLan.AddChildObjectL( KNSmlWLanConnRegainTimer );
+ FillNodeInfoL( connRegainTimer,
+ accessTypesGetAddReplace,
+ MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EInt,
+ KNSmlEmpty );
+
+ //WLAN/MaxTriesToFindNw
+ MSmlDmDDFObject& maxTriesToFindNw = rootWLan.AddChildObjectL( KNSmlWLanMaxTriesToFindNw );
+ FillNodeInfoL( maxTriesToFindNw,
+ accessTypesGetAddReplace,
+ MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EInt,
+ KNSmlEmpty );
+
+ //WLAN/DelayBetweenFindNw
+ MSmlDmDDFObject& delayBetweenFindNw = rootWLan.AddChildObjectL( KNSmlWLanDelayBetweenFindNw );
+ FillNodeInfoL( delayBetweenFindNw,
+ accessTypesGetAddReplace,
+ MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EInt,
+ KNSmlEmpty );
+
+ //WLAN/AllowRadioMeasurements
+ MSmlDmDDFObject& allowRadioMeasurements = rootWLan.AddChildObjectL( KNSmlWLanAllowRadioMeasurements );
+ FillNodeInfoL( allowRadioMeasurements,
+ accessTypesGetAddReplace,
+ MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EBool,
+ KNSmlEmpty );
+
+ //WLAN/MinPassiveChannelTime
+ MSmlDmDDFObject& minPassiveChannelTime = rootWLan.AddChildObjectL( KNSmlWLanMinPassiveChannelTime );
+ FillNodeInfoL( minPassiveChannelTime,
+ accessTypesGetAddReplace,
+ MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EInt,
+ KNSmlEmpty );
+
+ //WLAN/MaxPassiveChannelTime
+ MSmlDmDDFObject& maxPassiveChannelTime = rootWLan.AddChildObjectL( KNSmlWLanMaxPassiveChannelTime );
+ FillNodeInfoL( maxPassiveChannelTime,
+ accessTypesGetAddReplace,
+ MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EInt,
+ KNSmlEmpty );
+
+ //WLAN/MaxApFailureCount
+ MSmlDmDDFObject& maxApFailureCount = rootWLan.AddChildObjectL( KNSmlWLanMaxApFailureCount );
+ FillNodeInfoL( maxApFailureCount,
+ accessTypesGetAddReplace,
+ MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EInt,
+ KNSmlEmpty );
+
+ //WLAN/LongBeaconFindCount
+ MSmlDmDDFObject& longBeaconFindCount = rootWLan.AddChildObjectL( KNSmlWLanLongBeaconFindCount );
+ FillNodeInfoL( longBeaconFindCount,
+ accessTypesGetAddReplace,
+ MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EInt,
+ KNSmlEmpty );
+
+ //WLAN/QosNullFrameInterval
+ MSmlDmDDFObject& qosNullFrameInterval = rootWLan.AddChildObjectL( KNSmlWLanQosNullFrameInterval );
+ FillNodeInfoL( qosNullFrameInterval,
+ accessTypesGetAddReplace,
+ MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EInt,
+ KNSmlEmpty );
+
+ //WLAN/QosNullFrameTimeout
+ MSmlDmDDFObject& qosNullFrameTimeout = rootWLan.AddChildObjectL( KNSmlWLanQosNullFrameTimeout );
+ FillNodeInfoL( qosNullFrameTimeout,
+ accessTypesGetAddReplace,
+ MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EInt,
+ KNSmlEmpty );
+
+ //WLAN/MTU
+ MSmlDmDDFObject& MTU = rootWLan.AddChildObjectL( KNSmlWLanMTU );
+ FillNodeInfoL( MTU,
+ accessTypesGetAddReplace,
+ MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EInt,
+ KNSmlEmpty );
+
+
+ _DBG_FILE("CGlobalWLANAdapter::DDFStructureL(): end");
+ }
+
+
+
+//-----------------------------------------------------------------------------
+// CGlobalWLANAdapter* CGlobalWLANAdapter::AddLeafObjectL( const TDesC& aURI,const
+// TDesC& aParentLUID, const TDesC8& aObject, const TDesC& aType,
+// const TInt aStatusRef )
+//-----------------------------------------------------------------------------
+void CGlobalWLANAdapter::AddLeafObjectL( const TDesC8& aURI,
+ const TDesC8& aParentLUID,
+ const TDesC8& aObject,
+ const TDesC8& /*aType*/,
+ const TInt aStatusRef )
+ {
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::AddLeafObjectL - <%S> <%S>"), &aURI, &aParentLUID );
+
+ // Get the last uri segment and the number of uri items in the input
+ TInt uriSegs = NumOfUriSegs( aURI );
+ TInt err(KErrNone);
+ TPtrC8 lastUriSeg = GetLastUriSeg( aURI );
+
+ //**************************************************************************
+ // Check which leaf is in question
+ //**************************************************************************
+ if( aURI.Match( _L8("WLAN/*" ) ) != KErrNotFound && uriSegs==2 )
+ {
+ // *****************************************************************
+ if( lastUriSeg.Match( KNSmlWLanInternetConnectivityTest ) != KErrNotFound )
+ {
+ // check whether input is of legal size
+ if ( aObject.Size() <= KInputMaxLength )
+ {
+ //store the parameter
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::AddLeafObjectL, add leaf - <%S>"), &aURI );
+
+ err = DesToInt( aObject );
+ if ( err >= 0 )
+ {
+ iWriteSettings->internetConnectivityTest = err;
+ iWriteSettings->internetConnectivityTestPresent = ETrue;
+ iWriteStatuses->internetConnectivityTestStatus = aStatusRef;
+ err = KErrNone;
+ }
+ }
+ else
+ {
+ err = KErrTooBig;
+ }
+ }
+
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanUseDefaultSettings ) != KErrNotFound )
+ {
+ // check whether input is of legal size
+ if ( aObject.Size() <= KInputMaxLength )
+ {
+ //store the parameter
+ if( aObject.MatchF( _L8("True")) != KErrNotFound ||
+ aObject.MatchF( _L8("true")) != KErrNotFound )
+ {
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::AddLeafObjectL, add leaf - <%S>"), &aURI );
+ iWriteSettings->useDefaultSettings = ETrue;
+ iWriteSettings->useDefaultSettingsPresent = ETrue;
+ iWriteStatuses->useDefaultSettingsStatus = aStatusRef;
+ }
+ else if ( aObject.MatchF( _L8("False")) != KErrNotFound ||
+ aObject.MatchF( _L8("false")) != KErrNotFound )
+ {
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::AddLeafObjectL, add leaf - <%S>"), &aURI );
+ iWriteSettings->useDefaultSettings = EFalse;
+ iWriteSettings->useDefaultSettingsPresent = ETrue;
+ iWriteStatuses->useDefaultSettingsStatus = aStatusRef;
+ }
+ else
+ {
+ err = KErrArgument;
+ }
+ }
+ else
+ {
+ err = KErrTooBig;
+ }
+ }
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanLongRetryLimit ) != KErrNotFound )
+ {
+ // check whether input is of legal size
+ if ( aObject.Size() <= KInputMaxLength )
+ {
+ //store the parameter
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::AddLeafObjectL, add leaf - <%S>"), &aURI );
+ err = DesToInt( aObject );
+ if ( err >= 0 )
+ {
+ iWriteSettings->longRetryLimit = err;
+ iWriteSettings->longRetryLimitPresent = ETrue;
+ iWriteStatuses->longRetryLimitStatus = aStatusRef;
+ err = KErrNone;
+ }
+ }
+ else
+ {
+ err = KErrTooBig;
+ }
+ }
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanShortRetryLimit ) != KErrNotFound )
+ {
+ // check whether input is of legal size
+ if ( aObject.Size() <= KInputMaxLength )
+ {
+ //store the parameter
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::AddLeafObjectL, add leaf - <%S>"), &aURI );
+ err = DesToInt( aObject );
+ if ( err >= 0 )
+ {
+ iWriteSettings->shortRetryLimit = err;
+ iWriteSettings->shortRetryLimitPresent = ETrue;
+ iWriteStatuses->shortRetryLimitStatus = aStatusRef;
+ err = KErrNone;
+ }
+ }
+ else
+ {
+ err = KErrTooBig;
+ }
+ }
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanRTSThreshold ) != KErrNotFound )
+ {
+ // check whether input is of legal size
+ if ( aObject.Size() <= KInputMaxLength )
+ {
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::AddLeafObjectL, add leaf - <%S>"), &aURI );
+ err = DesToInt( aObject );
+ if ( err >= 0 )
+ {
+ iWriteSettings->RTSThreshold = err;
+ iWriteSettings->RTSThresholdPresent = ETrue;
+ iWriteStatuses->RTSThresholdStatus = aStatusRef;
+ err = KErrNone;
+ }
+ }
+ else
+ {
+ err = KErrTooBig;
+ }
+ }
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanTXPowerLevel ) != KErrNotFound )
+ {
+ // check whether input is of legal size
+ if ( aObject.Size() <= KInputMaxLength )
+ {
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::AddLeafObjectL, add leaf - <%S>"), &aURI );
+ //store the parameter
+ err = DesToInt( aObject );
+ if ( err >= 0)
+ {
+ iWriteSettings->TXPowerLevel = err;
+ iWriteSettings->TXPowerLevelPresent = ETrue;
+ iWriteStatuses->TXPowerLevelStatus = aStatusRef;
+ err = KErrNone;
+ }
+ }
+ else
+ {
+ err = KErrTooBig;
+ }
+ }
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanPowerSaving ) != KErrNotFound )
+ {
+ // check whether input is of legal size
+ if ( aObject.Size() <= KInputMaxLength )
+ {
+ //store the parameter
+ if( aObject.MatchF( _L8("True")) != KErrNotFound ||
+ aObject.MatchF( _L8("true")) != KErrNotFound )
+ {
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::AddLeafObjectL, add leaf - <%S>"), &aURI );
+ iWriteSettings->powerSaving = ETrue;
+ iWriteSettings->powerSavingPresent = ETrue;
+ iWriteStatuses->powerSavingStatus = aStatusRef;
+ }
+ else if ( aObject.MatchF( _L8("False")) != KErrNotFound ||
+ aObject.MatchF( _L8("false")) != KErrNotFound )
+ {
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::AddLeafObjectL, add leaf - <%S>"), &aURI );
+ iWriteSettings->powerSaving = EFalse;
+ iWriteSettings->powerSavingPresent = ETrue;
+ iWriteStatuses->powerSavingStatus = aStatusRef;
+ }
+ else
+ {
+ err = KErrArgument;
+ }
+ }
+ else
+ {
+ err = KErrTooBig;
+ }
+ }
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanBackgroundScanInterval ) != KErrNotFound )
+ {
+ // check whether input is of legal size
+ if ( aObject.Size() <= KInputMaxLength )
+ {
+ //store the parameter
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::AddLeafObjectL, add leaf - <%S>"), &aURI );
+ err = DesToInt( aObject );
+ if ( err >= 0 )
+ {
+ iWriteSettings->backgroundScanInterval = err;
+ iWriteSettings->backgroundScanIntervalPresent = ETrue;
+ iWriteStatuses->backgroundScanIntervalStatus = aStatusRef;
+ err = KErrNone;
+ }
+ }
+ else
+ {
+ err = KErrTooBig;
+ }
+ }
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanScanRate ) != KErrNotFound )
+ {
+ // check whether input is of legal size
+ if ( aObject.Size() <= KInputMaxLength )
+ {
+ //store the parameter
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::AddLeafObjectL, add leaf - <%S>"), &aURI );
+ err = DesToInt( aObject );
+ if ( err >= 0 )
+ {
+ iWriteSettings->scanRate = err;
+ iWriteSettings->scanRatePresent = ETrue;
+ iWriteStatuses->scanRateStatus = aStatusRef;
+ err = KErrNone;
+ }
+ }
+ else
+ {
+ err = KErrTooBig;
+ }
+ }
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanRCPITrigger ) != KErrNotFound )
+ {
+ // check whether input is of legal size
+ if ( aObject.Size() <= KInputMaxLength )
+ {
+ //store the parameter
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::AddLeafObjectL, add leaf - <%S>"), &aURI );
+ err = DesToInt( aObject );
+ if ( err >= 0)
+ {
+ iWriteSettings->RCPITrigger = err;
+ iWriteSettings->RCPITriggerPresent = ETrue;
+ iWriteStatuses->RCPITriggerStatus = aStatusRef;
+ err = KErrNone;
+ }
+ }
+ else
+ {
+ err = KErrTooBig;
+ }
+ }
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanMinActiveChannelTime ) != KErrNotFound )
+ {
+ // check whether input is of legal size
+ if ( aObject.Size() <= KInputMaxLength )
+ {
+ //store the parameter
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::AddLeafObjectL, add leaf - <%S>"), &aURI );
+ err = DesToInt( aObject );
+ if ( err >= 0 )
+ {
+ iWriteSettings->minActiveChannelTime = err;
+ iWriteSettings->minActiveChannelTimePresent = ETrue;
+ iWriteStatuses->minActiveChannelTimeStatus = aStatusRef;
+ err = KErrNone;
+ }
+ }
+ else
+ {
+ err = KErrTooBig;
+ }
+ }
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanMaxActiveChannelTime ) != KErrNotFound )
+ {
+ // check whether input is of legal size
+ if ( aObject.Size() <= KInputMaxLength )
+ {
+ //store the parameter
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::AddLeafObjectL, add leaf - <%S>"), &aURI );
+ err = DesToInt( aObject );
+ if ( err >= 0)
+ {
+ iWriteSettings->maxActiveChannelTime = err;
+ iWriteSettings->maxActiveChannelTimePresent = ETrue;
+ iWriteStatuses->maxActiveChannelTimeStatus = aStatusRef;
+ err = KErrNone;
+ }
+ }
+ else
+ {
+ err = KErrTooBig;
+ }
+ }
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanMaxTxMSDULifeTime ) != KErrNotFound )
+ {
+ // check whether input is of legal size
+ if ( aObject.Size() <= KInputMaxLength )
+ {
+ //store the parameter
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::AddLeafObjectL, add leaf - <%S>"), &aURI );
+ err = DesToInt( aObject );
+ if ( err >= 0 )
+ {
+ iWriteSettings->maxTxMSDULifeTime = err;
+ iWriteSettings->maxTxMSDULifeTimePresent = ETrue;
+ iWriteStatuses->maxTxMSDULifeTimeStatus = aStatusRef;
+ err = KErrNone;
+ }
+ }
+ else
+ {
+ err = KErrTooBig;
+ }
+ }
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanScanExpirationTimer ) != KErrNotFound )
+ {
+ // check whether input is of legal size
+ if ( aObject.Size() <= KInputMaxLength )
+ {
+ //store the parameter
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::AddLeafObjectL, add leaf - <%S>"), &aURI );
+ err = DesToInt( aObject );
+ if ( err >= 0 )
+ {
+ iWriteSettings->scanExpirationTimer = err;
+ iWriteSettings->scanExpirationTimerPresent = ETrue;
+ iWriteStatuses->scanExpirationTimerStatus = aStatusRef;
+ err = KErrNone;
+ }
+ }
+ else
+ {
+ err = KErrTooBig;
+ }
+ }
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanUnloadDriverTimer ) != KErrNotFound )
+ {
+ // check whether input is of legal size
+ if ( aObject.Size() <= KInputMaxLength )
+ {
+ //store the parameter
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::AddLeafObjectL, add leaf - <%S>"), &aURI );
+ err = DesToInt( aObject );
+ if ( err >= 0 )
+ {
+ iWriteSettings->unloadDriverTimer = err;
+ iWriteSettings->unloadDriverTimerPresent = ETrue;
+ iWriteStatuses->unloadDriverTimerStatus = aStatusRef;
+ err = KErrNone;
+ }
+ }
+ else
+ {
+ err = KErrTooBig;
+ }
+ }
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanRoamTimer ) != KErrNotFound )
+ {
+ // check whether input is of legal size
+ if ( aObject.Size() <= KInputMaxLength )
+ {
+ //store the parameter
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::AddLeafObjectL, add leaf - <%S>"), &aURI );
+ err = DesToInt( aObject );
+ if ( err >= 0 )
+ {
+ iWriteSettings->roamTimer = err;
+ iWriteSettings->roamTimerPresent = ETrue;
+ iWriteStatuses->roamTimerStatus = aStatusRef;
+ err = KErrNone;
+ }
+ }
+ else
+ {
+ err = KErrTooBig;
+ }
+ }
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanRCPIDifference ) != KErrNotFound )
+ {
+ // check whether input is of legal size
+ if ( aObject.Size() <= KInputMaxLength )
+ {
+ //store the parameter
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::AddLeafObjectL, add leaf - <%S>"), &aURI );
+ err = DesToInt( aObject );
+ if ( err >= 0 )
+ {
+ iWriteSettings->RCPIDifference = err;
+ iWriteSettings->RCPIDifferencePresent = ETrue;
+ iWriteStatuses->RCPIDifferenceStatus = aStatusRef;
+ err = KErrNone;
+ }
+ }
+ else
+ {
+ err = KErrTooBig;
+ }
+ }
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanConnRegainTimer ) != KErrNotFound )
+ {
+ // check whether input is of legal size
+ if ( aObject.Size() <= KInputMaxLength )
+ {
+ //store the parameter
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::AddLeafObjectL, add leaf - <%S>"), &aURI );
+ err = DesToInt( aObject );
+ if ( err >= 0 )
+ {
+ iWriteSettings->connRegainTimer = err;
+ iWriteSettings->connRegainTimerPresent = ETrue;
+ iWriteStatuses->connRegainTimerStatus = aStatusRef;
+ err = KErrNone;
+ }
+ }
+ else
+ {
+ err = KErrTooBig;
+ }
+ }
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanMaxTriesToFindNw ) != KErrNotFound )
+ {
+ // check whether input is of legal size
+ if ( aObject.Size() <= KInputMaxLength )
+ {
+ //store the parameter
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::AddLeafObjectL, add leaf - <%S>"), &aURI );
+ err = DesToInt( aObject );
+ if ( err >= 0)
+ {
+ iWriteSettings->maxTriesToFindNw = err;
+ iWriteSettings->maxTriesToFindNwPresent = ETrue;
+ iWriteStatuses->maxTriesToFindNwStatus = aStatusRef;
+ err = KErrNone;
+ }
+ }
+ else
+ {
+ err = KErrTooBig;
+ }
+ }
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanDelayBetweenFindNw ) != KErrNotFound )
+ {
+ // check whether input is of legal size
+ if ( aObject.Size() <= KInputMaxLength )
+ {
+ //store the parameter
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::AddLeafObjectL, add leaf - <%S>"), &aURI );
+ err = DesToInt( aObject );
+ if ( err >= 0 )
+ {
+ iWriteSettings->delayBetweenFindNw = err;
+ iWriteSettings->delayBetweenFindNwPresent = ETrue;
+ iWriteStatuses->delayBetweenFindNwStatus = aStatusRef;
+ err = KErrNone;
+ }
+ }
+ else
+ {
+ err = KErrTooBig;
+ }
+ }
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanAllowRadioMeasurements ) != KErrNotFound )
+ {
+ // check whether input is of legal size
+ if ( aObject.Size() <= KInputMaxLength )
+ {
+ if( aObject.MatchF( _L8("True")) != KErrNotFound ||
+ aObject.MatchF( _L8("true")) != KErrNotFound )
+ {
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::AddLeafObjectL, add leaf - <%S>"), &aURI );
+ iWriteSettings->allowRadioMeasurements = ETrue;
+ iWriteSettings->allowRadioMeasurementsPresent = ETrue;
+ iWriteStatuses->allowRadioMeasurementsStatus = aStatusRef;
+ }
+ else if ( aObject.MatchF( _L8("False")) != KErrNotFound ||
+ aObject.MatchF( _L8("false")) != KErrNotFound )
+ {
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::AddLeafObjectL, add leaf - <%S>"), &aURI );
+ iWriteSettings->allowRadioMeasurements = EFalse;
+ iWriteSettings->allowRadioMeasurementsPresent = ETrue;
+ iWriteStatuses->allowRadioMeasurementsStatus = aStatusRef;
+ }
+ else
+ {
+ err = KErrArgument;
+ }
+ }
+ else
+ {
+ err = KErrTooBig;
+ }
+ }
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanMinPassiveChannelTime ) != KErrNotFound )
+ {
+ // check whether input is of legal size
+ if ( aObject.Size() <= KInputMaxLength )
+ {
+ //store the parameter
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::AddLeafObjectL, add leaf - <%S>"), &aURI );
+ err = DesToInt( aObject );
+ if ( err >= 0 )
+ {
+ iWriteSettings->minPassiveChannelTime = err;
+ iWriteSettings->minPassiveChannelTimePresent = ETrue;
+ iWriteStatuses->minPassiveChannelTimeStatus = aStatusRef;
+ err = KErrNone;
+ }
+ }
+ else
+ {
+ err = KErrTooBig;
+ }
+ }
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanMaxPassiveChannelTime ) != KErrNotFound )
+ {
+ // check whether input is of legal size
+ if ( aObject.Size() <= KInputMaxLength )
+ {
+ //store the parameter
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::AddLeafObjectL, add leaf - <%S>"), &aURI );
+ err = DesToInt( aObject );
+ if ( err >= 0 )
+ {
+ iWriteSettings->maxPassiveChannelTime = err;
+ iWriteSettings->maxPassiveChannelTimePresent = ETrue;
+ iWriteStatuses->maxPassiveChannelTimeStatus = aStatusRef;
+ err = KErrNone;
+ }
+ }
+ else
+ {
+ err = KErrTooBig;
+ }
+ }
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanMaxApFailureCount ) != KErrNotFound )
+ {
+ // check whether input is of legal size
+ if ( aObject.Size() <= KInputMaxLength )
+ {
+ //store the parameter
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::AddLeafObjectL, add leaf - <%S>"), &aURI );
+ err = DesToInt( aObject );
+ if ( err >= 0 )
+ {
+ iWriteSettings->maxApFailureCount = err;
+ iWriteSettings->maxApFailureCountPresent = ETrue;
+ iWriteStatuses->maxApFailureCountStatus = aStatusRef;
+ err = KErrNone;
+ }
+ }
+ else
+ {
+ err = KErrTooBig;
+ }
+ }
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanLongBeaconFindCount ) != KErrNotFound )
+ {
+ // check whether input is of legal size
+ if ( aObject.Size() <= KInputMaxLength )
+ {
+ //store the parameter
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::AddLeafObjectL, add leaf - <%S>"), &aURI );
+ err = DesToInt( aObject );
+ if ( err >= 0 )
+ {
+ iWriteSettings->longBeaconFindCount = err;
+ iWriteSettings->longBeaconFindCountPresent = ETrue;
+ iWriteStatuses->longBeaconFindCountStatus = aStatusRef;
+ err = KErrNone;
+ }
+ }
+ else
+ {
+ err = KErrTooBig;
+ }
+ }
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanQosNullFrameInterval ) != KErrNotFound )
+ {
+ // check whether input is of legal size
+ if ( aObject.Size() <= KInputMaxLength )
+ {
+ //store the parameter
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::AddLeafObjectL, add leaf - <%S>"), &aURI );
+ err = DesToInt( aObject );
+ if ( err >= 0 )
+ {
+ iWriteSettings->qosNullFrameInterval = err;
+ iWriteSettings->qosNullFrameIntervalPresent = ETrue;
+ iWriteStatuses->qosNullFrameIntervalStatus = aStatusRef;
+ err = KErrNone;
+ }
+ }
+ else
+ {
+ err = KErrTooBig;
+ }
+ }
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanQosNullFrameTimeout ) != KErrNotFound )
+ {
+ // check whether input is of legal size
+ if ( aObject.Size() <= KInputMaxLength )
+ {
+ //store the parameter
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::AddLeafObjectL, add leaf - <%S>"), &aURI );
+ err = DesToInt( aObject );
+ if ( err >= 0 )
+ {
+ iWriteSettings->qosNullFrameTimeout = err;
+ iWriteSettings->qosNullFrameTimeoutPresent = ETrue;
+ iWriteStatuses->qosNullFrameTimeoutStatus = aStatusRef;
+ err = KErrNone;
+ }
+ }
+ else
+ {
+ err = KErrTooBig;
+ }
+ }
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanMTU ) != KErrNotFound )
+ {
+ // check whether input is of legal size
+ if ( aObject.Size() <= KInputMaxLength )
+ {
+ //store the parameter
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::AddLeafObjectL, add leaf - <%S>"), &aURI );
+ err = DesToInt( aObject );
+ if ( err >= 0 )
+ {
+ iWriteSettings->MTU = err;
+ iWriteSettings->MTUPresent = ETrue;
+ iWriteStatuses->MTUStatus = aStatusRef;
+ err = KErrNone;
+ }
+ }
+ else
+ {
+ err = KErrTooBig;
+ }
+ }
+ // *****************************************************************
+ // The given leaf was not found
+ else
+ {
+ err = KErrNotFound;
+ }
+ }
+ else
+ {
+ // Something went wrong
+ _DBG_FILE("CGlobalWLANAdapter::AddLeafObjectL(): Leaf addition failed");
+ err = KErrGeneral;
+ }
+
+ // Update the possible failure to the status, success is updated when the
+ // actual writing to db is done
+ switch ( err )
+ {
+ case KErrTooBig:
+ iCallBack->SetStatusL( aStatusRef, CSmlDmAdapter::ETooLargeObject );
+ break;
+
+ case KErrNotFound:
+ iCallBack->SetStatusL( aStatusRef, CSmlDmAdapter::EInvalidObject );
+ break;
+
+ case KErrGeneral:
+ iCallBack->SetStatusL( aStatusRef, CSmlDmAdapter::EError );
+ break;
+
+ case KErrArgument:
+ iCallBack->SetStatusL( aStatusRef, CSmlDmAdapter::EInvalidObject );
+ break;
+
+ case KErrOverflow:
+ iCallBack->SetStatusL( aStatusRef, CSmlDmAdapter::EInvalidObject );
+ break;
+ }
+
+ _DBG_FILE("CGlobalWLANAdapter::AddLeafObjectL(): end");
+ }
+
+//-----------------------------------------------------------------------------
+// CGlobalWLANAdapter* CGlobalWLANAdapter::UpdateLeafObjectL( const TDesC& aURI,
+// const TDesC& aLUID, const TDesC8& aObject, const TDesC& aType,
+// const TInt aStatusRef )
+//-----------------------------------------------------------------------------
+void CGlobalWLANAdapter::UpdateLeafObjectL( const TDesC8& aURI,
+ const TDesC8& aLUID,
+ const TDesC8& aObject,
+ const TDesC8& aType,
+ const TInt aStatusRef )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::UpdateLeafObjectL(): begin");
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::UpdateLeafObjectL - <%S> <%S>"), &aURI, &aLUID );
+
+ AddLeafObjectL( aURI, aLUID, aObject, aType, aStatusRef );
+
+ _DBG_FILE("CGlobalWLANAdapter::UpdateLeafObjectL(): end");
+ }
+
+//------------------------------------------------------------------------------
+// CGlobalWLANAdapter::UpdateLeafObjectL( const TDesC8& aURI,
+// const TDesC8& aLUID, const TDesC8& aObject, const TDesC8& aType )
+// Not supported
+//------------------------------------------------------------------------------
+
+void CGlobalWLANAdapter::UpdateLeafObjectL( const TDesC8& /*aURI*/,
+ const TDesC8& /*aLUID*/,
+ RWriteStream*& /*aStream*/,
+ const TDesC8& /*aType*/,
+ TInt aStatusRef )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::UpdateLeafObjectL(): streaming: begin");
+
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+
+ _DBG_FILE("CGlobalWLANAdapter::UpdateLeafObjectL() streaming: end");
+ }
+
+//-----------------------------------------------------------------------------
+// CGlobalWLANAdapter* CGlobalWLANAdapter::DeleteObjectL( const TDesC8& aURI,
+// const TDesC8& aLUID, const TInt aStatusRef )
+// Not supported
+//-----------------------------------------------------------------------------
+void CGlobalWLANAdapter::DeleteObjectL( const TDesC8& /*aURI*/,
+ const TDesC8& /*aLUID*/,
+ const TInt aStatusRef )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::DeleteObjectL(): begin");
+
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+
+ _DBG_FILE("CGlobalWLANAdapter::DeleteObjectL(): end");
+ }
+
+//-----------------------------------------------------------------------------
+// CGlobalWLANAdapter* CGlobalWLANAdapter::FetchLeafObjectSizeL( const TDesC8& aURI,
+// const TDesC8& aLUID, const TDesC8& aType,
+// const TInt aResultsRef, const TInt aStatusRef )
+// not supported
+//-----------------------------------------------------------------------------
+
+void CGlobalWLANAdapter::FetchLeafObjectSizeL( const TDesC8& /*aURI*/,
+ const TDesC8& /*aLUID*/,
+ const TDesC8& /*aType*/,
+ TInt /*aResultsRef*/,
+ TInt /*aStatusRef*/ )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::FetchLeafObjectSizeL(): begin");
+ _DBG_FILE("CGlobalWLANAdapter::FetchLeafObjectSizeL(): end");
+ return;
+ }
+
+
+//-----------------------------------------------------------------------------
+// CGlobalWLANAdapter* CGlobalWLANAdapter::FetchLeafObjectL( const TDesC8& aURI,
+// const TDesC8& aLUID, const TDesC8& aType,
+// const TInt aResultsRef, const TInt aStatusRef )
+//
+//-----------------------------------------------------------------------------
+void CGlobalWLANAdapter::FetchLeafObjectL( const TDesC8& aURI,
+ const TDesC8& aLUID,
+ const TDesC8& /*aType*/,
+ const TInt aResultsRef,
+ const TInt aStatusRef )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::FetchLeafObjectL(): begin");
+ DBG_ARGS8(_S8("Fetch aURI - %S - %S"), &aURI, &aLUID);
+
+ // Store the required parameters into the struct. Actual reading will be done in
+ // when CompleteOutstandingCommands is called
+
+ // Get the last uri segment
+ TPtrC8 lastUriSeg = GetLastUriSeg( aURI );
+ DBG_ARGS8(_S8("Fetch leaf, lasturiseg - %S"), &lastUriSeg);
+
+ //**************************************************************************
+ // Check which leaf is in question
+ //**************************************************************************
+ if( aURI.Match( _L8("WLAN/*" ) ) != KErrNotFound )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::FetchLeafObjectL(): WLAN/* found in uri");
+ // *****************************************************************
+ if( lastUriSeg.Match( KNSmlWLanInternetConnectivityTest ) != KErrNotFound )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::FetchLeafObjectL(): leaf");
+ iReadSettings->internetConnectivityTestPresent = ETrue;
+ iReadStatuses->internetConnectivityTestResult = aResultsRef;
+ iReadStatuses->internetConnectivityTestStatus = aStatusRef;
+ }
+
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanUseDefaultSettings ) != KErrNotFound )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::FetchLeafObjectL(): leaf");
+ iReadSettings->useDefaultSettingsPresent = ETrue;
+ iReadStatuses->useDefaultSettingsResult = aResultsRef;
+ iReadStatuses->useDefaultSettingsStatus = aStatusRef;
+ }
+
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanLongRetryLimit ) != KErrNotFound )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::FetchLeafObjectL(): leaf");
+ iReadSettings->longRetryLimitPresent = ETrue;
+ iReadStatuses->longRetryLimitResult = aResultsRef;
+ iReadStatuses->longRetryLimitStatus = aStatusRef;
+ }
+
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanShortRetryLimit ) != KErrNotFound )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::FetchLeafObjectL(): leaf");
+ iReadSettings->shortRetryLimitPresent = ETrue;
+ iReadStatuses->shortRetryLimitResult = aResultsRef;
+ iReadStatuses->shortRetryLimitStatus = aStatusRef;
+ }
+
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanRTSThreshold ) != KErrNotFound )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::FetchLeafObjectL(): leaf");
+ iReadSettings->RTSThresholdPresent = ETrue;
+ iReadStatuses->RTSThresholdResult = aResultsRef;
+ iReadStatuses->RTSThresholdStatus = aStatusRef;
+ }
+
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanTXPowerLevel ) != KErrNotFound )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::FetchLeafObjectL(): leaf");
+ iReadSettings->TXPowerLevelPresent = ETrue;
+ iReadStatuses->TXPowerLevelResult = aResultsRef;
+ iReadStatuses->TXPowerLevelStatus = aStatusRef;
+ }
+
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanPowerSaving ) != KErrNotFound )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::FetchLeafObjectL(): leaf");
+ iReadSettings->powerSavingPresent = ETrue;
+ iReadStatuses->powerSavingResult = aResultsRef;
+ iReadStatuses->powerSavingStatus = aStatusRef;
+ }
+
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanBackgroundScanInterval ) != KErrNotFound )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::FetchLeafObjectL(): leaf");
+ iReadSettings->backgroundScanIntervalPresent = ETrue;
+ iReadStatuses->backgroundScanIntervalResult = aResultsRef;
+ iReadStatuses->backgroundScanIntervalStatus = aStatusRef;
+ }
+
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanScanRate ) != KErrNotFound )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::FetchLeafObjectL(): leaf");
+ iReadSettings->scanRatePresent = ETrue;
+ iReadStatuses->scanRateResult = aResultsRef;
+ iReadStatuses->scanRateStatus = aStatusRef;
+ }
+
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanRCPITrigger ) != KErrNotFound )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::FetchLeafObjectL(): leaf");
+ iReadSettings->RCPITriggerPresent = ETrue;
+ iReadStatuses->RCPITriggerResult = aResultsRef;
+ iReadStatuses->RCPITriggerStatus = aStatusRef;
+ }
+
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanMinActiveChannelTime ) != KErrNotFound )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::FetchLeafObjectL(): leaf");
+ iReadSettings->minActiveChannelTimePresent = ETrue;
+ iReadStatuses->minActiveChannelTimeResult = aResultsRef;
+ iReadStatuses->minActiveChannelTimeStatus = aStatusRef;
+ }
+
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanMaxActiveChannelTime ) != KErrNotFound )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::FetchLeafObjectL(): leaf");
+ iReadSettings->maxActiveChannelTimePresent = ETrue;
+ iReadStatuses->maxActiveChannelTimeResult = aResultsRef;
+ iReadStatuses->maxActiveChannelTimeStatus = aStatusRef;
+ }
+
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanMaxTxMSDULifeTime ) != KErrNotFound )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::FetchLeafObjectL(): leaf");
+ iReadSettings->maxTxMSDULifeTimePresent = ETrue;
+ iReadStatuses->maxTxMSDULifeTimeResult = aResultsRef;
+ iReadStatuses->maxTxMSDULifeTimeStatus = aStatusRef;
+ }
+
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanScanExpirationTimer ) != KErrNotFound )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::FetchLeafObjectL(): leaf");
+ iReadSettings->scanExpirationTimerPresent = ETrue;
+ iReadStatuses->scanExpirationTimerResult = aResultsRef;
+ iReadStatuses->scanExpirationTimerStatus = aStatusRef;
+ }
+
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanUnloadDriverTimer ) != KErrNotFound )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::FetchLeafObjectL(): leaf");
+ iReadSettings->unloadDriverTimerPresent = ETrue;
+ iReadStatuses->unloadDriverTimerResult = aResultsRef;
+ iReadStatuses->unloadDriverTimerStatus = aStatusRef;
+ }
+
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanRoamTimer ) != KErrNotFound )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::FetchLeafObjectL(): leaf");
+ iReadSettings->roamTimerPresent = ETrue;
+ iReadStatuses->roamTimerResult = aResultsRef;
+ iReadStatuses->roamTimerStatus = aStatusRef;
+ }
+
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanRCPIDifference ) != KErrNotFound )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::FetchLeafObjectL(): leaf");
+ iReadSettings->RCPIDifferencePresent = ETrue;
+ iReadStatuses->RCPIDifferenceResult = aResultsRef;
+ iReadStatuses->RCPIDifferenceStatus = aStatusRef;
+ }
+
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanConnRegainTimer ) != KErrNotFound )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::FetchLeafObjectL(): leaf");
+ iReadSettings->connRegainTimerPresent = ETrue;
+ iReadStatuses->connRegainTimerResult = aResultsRef;
+ iReadStatuses->connRegainTimerStatus = aStatusRef;
+ }
+
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanMaxTriesToFindNw ) != KErrNotFound )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::FetchLeafObjectL(): leaf");
+ iReadSettings->maxTriesToFindNwPresent = ETrue;
+ iReadStatuses->maxTriesToFindNwResult = aResultsRef;
+ iReadStatuses->maxTriesToFindNwStatus = aStatusRef;
+ }
+
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanDelayBetweenFindNw ) != KErrNotFound )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::FetchLeafObjectL(): leaf");
+ iReadSettings->delayBetweenFindNwPresent = ETrue;
+ iReadStatuses->delayBetweenFindNwResult = aResultsRef;
+ iReadStatuses->delayBetweenFindNwStatus = aStatusRef;
+ }
+
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanAllowRadioMeasurements ) != KErrNotFound )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::FetchLeafObjectL(): leaf");
+ iReadSettings->allowRadioMeasurementsPresent = ETrue;
+ iReadStatuses->allowRadioMeasurementsResult = aResultsRef;
+ iReadStatuses->allowRadioMeasurementsStatus = aStatusRef;
+ }
+
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanMinPassiveChannelTime ) != KErrNotFound )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::FetchLeafObjectL(): leaf");
+ iReadSettings->minPassiveChannelTimePresent = ETrue;
+ iReadStatuses->minPassiveChannelTimeResult = aResultsRef;
+ iReadStatuses->minPassiveChannelTimeStatus = aStatusRef;
+ }
+
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanMaxPassiveChannelTime ) != KErrNotFound )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::FetchLeafObjectL(): leaf");
+ iReadSettings->maxPassiveChannelTimePresent = ETrue;
+ iReadStatuses->maxPassiveChannelTimeResult = aResultsRef;
+ iReadStatuses->maxPassiveChannelTimeStatus = aStatusRef;
+ }
+
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanMaxApFailureCount ) != KErrNotFound )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::FetchLeafObjectL(): leaf");
+ iReadSettings->maxApFailureCountPresent = ETrue;
+ iReadStatuses->maxApFailureCountResult = aResultsRef;
+ iReadStatuses->maxApFailureCountStatus = aStatusRef;
+ }
+
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanLongBeaconFindCount ) != KErrNotFound )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::FetchLeafObjectL(): leaf");
+ iReadSettings->longBeaconFindCountPresent = ETrue;
+ iReadStatuses->longBeaconFindCountResult = aResultsRef;
+ iReadStatuses->longBeaconFindCountStatus = aStatusRef;
+ }
+
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanQosNullFrameInterval ) != KErrNotFound )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::FetchLeafObjectL(): leaf");
+ iReadSettings->qosNullFrameIntervalPresent = ETrue;
+ iReadStatuses->qosNullFrameIntervalResult = aResultsRef;
+ iReadStatuses->qosNullFrameIntervalStatus = aStatusRef;
+ }
+
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanQosNullFrameTimeout ) != KErrNotFound )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::FetchLeafObjectL(): leaf");
+ iReadSettings->qosNullFrameTimeoutPresent = ETrue;
+ iReadStatuses->qosNullFrameTimeoutResult = aResultsRef;
+ iReadStatuses->qosNullFrameTimeoutStatus = aStatusRef;
+ }
+
+ // *****************************************************************
+ else if( lastUriSeg.Match( KNSmlWLanMTU ) != KErrNotFound )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::FetchLeafObjectL(): leaf");
+ iReadSettings->MTUPresent = ETrue;
+ iReadStatuses->MTUResult = aResultsRef;
+ iReadStatuses->MTUStatus = aStatusRef;
+ }
+
+ // *****************************************************************
+ // The given leaf was not found
+ else
+ {
+ _DBG_FILE("CGlobalWLANAdapter::FetchLeafObjectL(): No matchin leaf was found");
+ iCallBack->SetStatusL(aStatusRef, ENotFound);
+ }
+ }
+ else
+ {
+ // Something went wrong
+ _DBG_FILE("CGlobalWLANAdapter::FetchLeafObjectL(): No matchin node was found");
+ iCallBack->SetStatusL(aStatusRef, EInvalidObject);
+ }
+
+ _DBG_FILE("CGlobalWLANAdapter::FetchLeafObjectL(): end");
+
+ }
+
+
+//-----------------------------------------------------------------------------
+// CGlobalWLANAdapter* CGlobalWLANAdapter::ChildURIListL( const TDesC& aURI,
+// const TDesC& aLUID, const CArrayFix<TNSmlDmMappingInfo>& aPreviousURISegmentList,
+// const TInt aResultsRef, const TInt aStatusRef )
+//-----------------------------------------------------------------------------
+void CGlobalWLANAdapter::ChildURIListL( const TDesC8& aURI,
+ const TDesC8& /*aLUID*/,
+ const CArrayFix<TSmlDmMappingInfo>& /*aPreviousURISegmentList*/,
+ const TInt aResultsRef,
+ const TInt aStatusRef )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::ChildURIListL(): begin");
+ DBG_ARGS8(_S8("globalwlanadapter::ChildUriList - <%S>"), &aURI );
+
+ CBufBase* currentUriSegmentList = CBufFlat::NewL( KUriSegListLength );
+ CleanupStack::PushL( currentUriSegmentList );
+ TEntry currentEntry;
+ TInt uriSegs = NumOfUriSegs( aURI );
+
+ // Check whether WLAN node in question
+ if ( aURI.Match(_L8("WLAN" ))!= KErrNotFound && uriSegs == 1 )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::ChildURIListL(): WLAN");
+ currentUriSegmentList->InsertL( 0, KNSmlWLanNode );
+ iCallBack->SetResultsL( aResultsRef, *currentUriSegmentList, KNullDesC8 );
+ iCallBack->SetStatusL( aStatusRef, CSmlDmAdapter::EOk );
+ _DBG_FILE("CGlobalWLANAdapter::ChildURIListL(): WLAN leafs returned");
+ }
+
+ // Some illegal node/leaf in question
+ else
+ {
+ iCallBack->SetStatusL(aStatusRef,CSmlDmAdapter::ENotFound);
+ _DBG_FILE("CNSmlInternetAdapter::ChildURIListL(): ENotFound end");
+ }
+
+ // delete the list
+ CleanupStack::PopAndDestroy( currentUriSegmentList );
+ _DBG_FILE("CGlobalWLANAdapter::ChildURIListL(): end");
+ }
+
+//-----------------------------------------------------------------------------
+// void CGlobalWLANAdapter::AddNodeObjectL( const TDesC& aURI, const TDesC& aParentLUID,
+// const TInt aStatusRef )
+//-----------------------------------------------------------------------------
+void CGlobalWLANAdapter::AddNodeObjectL( const TDesC8& aURI,
+ const TDesC8& aParentLUID,
+ const TInt aStatusRef )
+ {
+
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::AddNodeObjectL - uri: <%S> to aParentLuid: <%S>"),
+ &aURI, &aParentLUID );
+
+ TInt uriSegs = NumOfUriSegs( aURI );
+
+ // The only node is WLAN, lets check if that is in question
+ if( aURI.Match( _L8("WLAN" ) ) != KErrNotFound && uriSegs==1 )
+ {
+ // No actions needed, the table is created and filled in the
+ // Execution function.
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ }
+ else
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ }
+
+ _DBG_FILE("CGlobalWLANAdapter::AddNodeObjectL(): end");
+ }
+
+//------------------------------------------------------------------------------
+// CGlobalWLANAdapter::ExecuteCommandL
+// not supported
+//------------------------------------------------------------------------------
+void CGlobalWLANAdapter::ExecuteCommandL( const TDesC8& /*aURI*/,
+ const TDesC8& /*aLUID*/,
+ const TDesC8& /*aArgument*/,
+ const TDesC8& /*aType*/,
+ TInt aStatusRef )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::ExecuteCommandL(): begin");
+
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+
+ _DBG_FILE("CGlobalWLANAdapter::ExecuteCommandL(): end");
+ }
+
+//------------------------------------------------------------------------------
+// CGlobalWLANAdapter::ExecuteCommandL ( .. RWriteStream ..)
+// not supported
+//------------------------------------------------------------------------------
+void CGlobalWLANAdapter::ExecuteCommandL( const TDesC8& /*aURI*/,
+ const TDesC8& /*aLUID*/,
+ RWriteStream*& /*aStream*/,
+ const TDesC8& /*aType*/,
+ TInt aStatusref )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::ExecuteCommandL(): begin");
+
+ iCallBack->SetStatusL( aStatusref, CSmlDmAdapter::EError );
+
+ _DBG_FILE("CGlobalWLANAdapter::ExecuteCommandL(): end");
+ }
+
+//------------------------------------------------------------------------------
+// CGlobalWLANAdapter::CopyCommandL
+// not supported
+//------------------------------------------------------------------------------
+void CGlobalWLANAdapter::CopyCommandL( const TDesC8& /*aTargetURI*/,
+ const TDesC8& /*aTargetLUID*/,
+ const TDesC8& /* aSourceURI*/,
+ const TDesC8& /*aSourceLUID*/,
+ const TDesC8& /*aType*/,
+ TInt aStatusRef )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::CopyCommandL(): begin");
+
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+
+ _DBG_FILE("CGlobalWLANAdapter::CopyCommandL(): end");
+ }
+//------------------------------------------------------------------------------
+// CGlobalWLANAdapter::StartAtomicL
+// not supported
+//------------------------------------------------------------------------------
+void CGlobalWLANAdapter::StartAtomicL()
+ {
+ _DBG_FILE("CGlobalWLANAdapter::StartAtomicL(): begin");
+ _DBG_FILE("CGlobalWLANAdapter::StartAtomicL(): end");
+ }
+
+//------------------------------------------------------------------------------
+// CGlobalWLANAdapter::CommitAtomicL
+// not supported
+//------------------------------------------------------------------------------
+void CGlobalWLANAdapter::CommitAtomicL()
+ {
+ _DBG_FILE("CGlobalWLANAdapter::CommitAtomicL(): begin");
+ _DBG_FILE("CGlobalWLANAdapter::CommitAtomicL(): end");
+ }
+
+//------------------------------------------------------------------------------
+// CGlobalWLANAdapter::RollbackAtomicL
+// returns EError
+//------------------------------------------------------------------------------
+void CGlobalWLANAdapter::RollbackAtomicL()
+ {
+ _DBG_FILE("CGlobalWLANAdapter::RollbackAtomicL(): begin");
+ _DBG_FILE("CGlobalWLANAdapter::RollbackAtomicL(): end");
+ }
+
+
+//------------------------------------------------------------------------------
+// CGlobalWLANAdapter::StreamingSupport
+// returns ETrue, streaming is supported
+//------------------------------------------------------------------------------
+
+TBool CGlobalWLANAdapter::StreamingSupport( TInt& /*aItemSize*/ )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::StreamingSupport(): begin");
+ _DBG_FILE("CGlobalWLANAdapter::StreamingSupport(): end");
+ return EFalse;
+ }
+
+//------------------------------------------------------------------------------
+// CGlobalWLANAdapter::StreamCommittedL
+// not used in this adapter
+//------------------------------------------------------------------------------
+
+void CGlobalWLANAdapter::StreamCommittedL()
+ {
+ _DBG_FILE("CGlobalWLANAdapter::StreamCommittedL(): begin");
+ _DBG_FILE("CGlobalWLANAdapter::StreamCommittedL(): end");
+ }
+
+//-----------------------------------------------------------------------------
+// CGlobalWLANAdapter* CGlobalWLANAdapter::CompleteOutstandingCmdsL( )
+//-----------------------------------------------------------------------------
+void CGlobalWLANAdapter::CompleteOutstandingCmdsL( )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::CompleteOutStandingCmdsL(): begin");
+
+ ExecuteBufferL( ETrue );
+
+ _DBG_FILE("CGlobalWLANAdapter::CompleteOutStandingCmdsL(): end");
+ }
+
+
+// -------------------------------------------------------------------------------------
+// CGlobalWLANAdapter::FillNodeInfoL()
+// Fills the node info in ddf structure
+// -------------------------------------------------------------------------------------
+void CGlobalWLANAdapter::FillNodeInfoL( MSmlDmDDFObject& aNode,
+ TSmlDmAccessTypes aAccTypes,
+ MSmlDmDDFObject::TOccurence aOccurrence,
+ MSmlDmDDFObject::TScope aScope,
+ MSmlDmDDFObject::TDFFormat aFormat,
+ const TDesC8& aDescription )
+
+ {
+ aNode.SetAccessTypesL(aAccTypes);
+ aNode.SetOccurenceL(aOccurrence);
+ aNode.SetScopeL(aScope);
+ aNode.SetDFFormatL(aFormat);
+ if(aFormat!=MSmlDmDDFObject::ENode)
+ {
+ aNode.AddDFTypeMimeTypeL(KNSmlMimeType);
+ }
+ aNode.SetDescriptionL(aDescription);
+ }
+
+
+// ------------------------------------------------------------------------------------------------
+// void CGlobalWLANAdapter::ExecuteBufferL( TBool aFinal )
+// Executes buffered commands
+// ------------------------------------------------------------------------------------------------
+void CGlobalWLANAdapter::ExecuteBufferL( TBool /*aFinal*/ )
+ {
+
+ _DBG_FILE("CGlobalWLANAdapter::ExecuteBuffer(): begin");
+
+ // Store the given values into cenrep and commsdb and
+ // read the required parameters from cenrep and commsdb
+ TRAPD (err1, StoreCenRepParamsL());
+ TRAPD (err2, StoreCommsDBParamsL());
+ TRAPD (err3, ReadCenRepParamsL());
+ TRAPD (err4, ReadCommsDBParamsL());
+
+ // Init the member variables after updates
+ InitMemberVariables();
+
+ // If some of the operations failed, then leave
+ User::LeaveIfError( err1 );
+ User::LeaveIfError( err2 );
+ User::LeaveIfError( err3 );
+ User::LeaveIfError( err4 );
+
+ _DBG_FILE("CGlobalWLANAdapter::ExecuteBuffer(): End");
+ }
+
+
+// ------------------------------------------------------------------------------------------------
+// TBool CGlobalWLANAdapter::StoreCenRepParamsL( )
+// Stores the parameters to central repository
+// ------------------------------------------------------------------------------------------------
+void CGlobalWLANAdapter::StoreCenRepParamsL()
+ {
+
+ _DBG_FILE("CGlobalWLANAdapter::StoreCenRepParams(): begin");
+
+ CRepository* repository = NULL;
+ CRepository* conSettRep = NULL;
+ TInt err = KErrNone;
+
+
+ // Write KWlanInternetConnectivityTest
+ if ( iWriteSettings->internetConnectivityTestPresent )
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams() KWlanInternetConnectivityTest start " );
+ // Open the cenrep for internet connectivity settings. This is the only global wlan parameter
+ // from this cenrep
+ conSettRep = CRepository::NewL( KCRUidInternetConnectivitySettings );
+
+ // There is no pointer to the repository, leave
+ if ( conSettRep == NULL )
+ {
+ User::LeaveIfError( KErrGeneral );
+ }
+
+ CleanupStack::PushL(conSettRep);
+
+ err = conSettRep->Set( KIctsTestPermission, static_cast<TInt>( iWriteSettings->internetConnectivityTest ) );
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams() KWlanInternetConnectivityTest set to cenRep " );
+ if( err == KErrNone )
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams() KWlanInternetConnectivityTest" );
+ iCallBack->SetStatusL(iWriteStatuses->internetConnectivityTestStatus, CSmlDmAdapter::EOk);
+ }
+ else
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams() KWlanInternetConnectivityTest failed " );
+ iCallBack->SetStatusL(iWriteStatuses->internetConnectivityTestStatus, CSmlDmAdapter::EError);
+ }
+ CleanupStack::PopAndDestroy(conSettRep);
+ }
+
+
+ // The rest of the parameters are stored to Wlan device settings cenRep
+ repository = CRepository::NewL( KCRUidWlanDeviceSettingsRegistryId );
+
+ // There is no pointer to the repository, leave
+ if ( repository == NULL )
+ {
+ User::LeaveIfError( KErrGeneral );
+ }
+
+ CleanupStack::PushL(repository);
+
+ if ( iWriteSettings->MTUPresent )
+ {
+ err = repository->Set( KWlanMTU, static_cast<TInt>( iWriteSettings->MTU ) );
+
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::StoreCenRepParams, MTU status - (%d)"), err );
+ if( err == KErrNone )
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams() MTU" );
+ iCallBack->SetStatusL(iWriteStatuses->MTUStatus, CSmlDmAdapter::EOk);
+ }
+ else
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams() MTU failed " );
+ iCallBack->SetStatusL(iWriteStatuses->MTUStatus, CSmlDmAdapter::EError);
+ }
+ }
+
+ // Write KWlanScanRate
+ if ( iWriteSettings->scanRatePresent )
+ {
+ err = repository->Set( KWlanScanRate, static_cast<TInt>( iWriteSettings->scanRate ) );
+
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::StoreCenRepParams, scanrate status - (%d)"), err );
+ if( err == KErrNone )
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams() WlanScanRate" );
+ iCallBack->SetStatusL(iWriteStatuses->scanRateStatus, CSmlDmAdapter::EOk);
+ }
+ else
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams() WlanScanRate failed " );
+ iCallBack->SetStatusL(iWriteStatuses->scanRateStatus, CSmlDmAdapter::EError);
+ }
+ }
+
+ // Write KWlanRcpiTrigger
+ if ( iWriteSettings->RCPITriggerPresent )
+ {
+ err = repository->Set( KWlanRcpiTrigger, static_cast<TInt>( iWriteSettings->RCPITrigger ) );
+
+ if( err == KErrNone )
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams() KWlanRcpiTrigger" );
+ iCallBack->SetStatusL(iWriteStatuses->RCPITriggerStatus, CSmlDmAdapter::EOk);
+ }
+ else
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams() KWlanRcpiTrigger failed" );
+ iCallBack->SetStatusL(iWriteStatuses->RCPITriggerStatus, CSmlDmAdapter::EError);
+ }
+ }
+
+ // Write KWlanMinActiveChannelTime
+ if ( iWriteSettings->minActiveChannelTimePresent )
+ {
+ err = repository->Set( KWlanMinActiveChannelTime, static_cast<TInt>( iWriteSettings->minActiveChannelTime ) );
+
+ if( err == KErrNone )
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams() KWlanMinActiveChannelTime" );
+ iCallBack->SetStatusL(iWriteStatuses->minActiveChannelTimeStatus, CSmlDmAdapter::EOk);
+ }
+ else
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams() KWlanMinActiveChannelTime failed" );
+ iCallBack->SetStatusL(iWriteStatuses->minActiveChannelTimeStatus, CSmlDmAdapter::EError);
+ }
+ }
+
+ // Write KWlanMaxActiveChannelTime
+ if ( iWriteSettings->maxActiveChannelTimePresent )
+ {
+ err = repository->Set( KWlanMaxActiveChannelTime, static_cast<TInt>( iWriteSettings->maxActiveChannelTime ) );
+
+ if( err == KErrNone )
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams() KWlanMaxActiveChannelTime" );
+ iCallBack->SetStatusL(iWriteStatuses->maxActiveChannelTimeStatus, CSmlDmAdapter::EOk);
+ }
+ else
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams() KWlanMaxActiveChannelTime failed" );
+ iCallBack->SetStatusL(iWriteStatuses->maxActiveChannelTimeStatus, CSmlDmAdapter::EError);
+ }
+ }
+
+ // Write KWlanMaxTxMSDULifeTime
+ if ( iWriteSettings->maxTxMSDULifeTimePresent )
+ {
+ err = repository->Set( KWlanMaxTxMSDULifeTime, static_cast<TInt>( iWriteSettings->maxTxMSDULifeTime ) );
+
+ if( err == KErrNone )
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams()KWlanMaxTxMSDULifeTime" );
+ iCallBack->SetStatusL(iWriteStatuses->maxTxMSDULifeTimeStatus, CSmlDmAdapter::EOk);
+ }
+ else
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams()KWlanMaxTxMSDULifeTime failed" );
+ iCallBack->SetStatusL(iWriteStatuses->maxTxMSDULifeTimeStatus, CSmlDmAdapter::EError);
+ }
+ }
+
+ // Write KWlanScanExpirationTimer
+ if ( iWriteSettings->scanExpirationTimerPresent )
+ {
+ err = repository->Set( KWlanScanExpirationTimer, static_cast<TInt>( iWriteSettings->scanExpirationTimer ) );
+
+ if( err == KErrNone )
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams()KWlanScanExpirationTimer" );
+ iCallBack->SetStatusL(iWriteStatuses->scanExpirationTimerStatus, CSmlDmAdapter::EOk);
+ }
+ else
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams()KWlanScanExpirationTimer failed" );
+ iCallBack->SetStatusL(iWriteStatuses->scanExpirationTimerStatus, CSmlDmAdapter::EError);
+ }
+ }
+
+ // Write KWlanUnloadDriverTimer
+ if ( iWriteSettings->unloadDriverTimerPresent )
+ {
+ err = repository->Set( KWlanUnloadDriverTimer, static_cast<TInt>( iWriteSettings->unloadDriverTimer ) );
+
+ if( err == KErrNone )
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams()KWlanUnloadDriverTimer" );
+ iCallBack->SetStatusL(iWriteStatuses->unloadDriverTimerStatus, CSmlDmAdapter::EOk);
+ }
+ else
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams()KWlanUnloadDriverTimer failed" );
+ iCallBack->SetStatusL(iWriteStatuses->unloadDriverTimerStatus, CSmlDmAdapter::EError);
+ }
+ }
+
+ // Write KWlanRoamTimer
+ if ( iWriteSettings->roamTimerPresent )
+ {
+ err = repository->Set( KWlanRoamTimer, static_cast<TInt>( iWriteSettings->roamTimer ) );
+
+ if( err == KErrNone)
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams() KWlanRoamTimer" );
+ iCallBack->SetStatusL(iWriteStatuses->roamTimerStatus, CSmlDmAdapter::EOk);
+ }
+ else
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams() KWlanRoamTimer failed" );
+ iCallBack->SetStatusL(iWriteStatuses->roamTimerStatus, CSmlDmAdapter::EError);
+ }
+ }
+
+ // Write KWlanRcpiDifference
+ if ( iWriteSettings->RCPIDifferencePresent )
+ {
+ err = repository->Set( KWlanRcpiDifference, static_cast<TInt>( iWriteSettings->RCPIDifference ) );
+
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::StoreCenRepParams, rcpidifference status - (%d)"), err );
+ if( err == KErrNone)
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams() KWlanRcpiDifference" );
+ iCallBack->SetStatusL(iWriteStatuses->RCPIDifferenceStatus, CSmlDmAdapter::EOk);
+ }
+ else
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams() KWlanRcpiDifference failed" );
+ iCallBack->SetStatusL(iWriteStatuses->RCPIDifferenceStatus, CSmlDmAdapter::EError);
+ }
+ }
+
+ // Write KWlanConnRegainTimer
+ if ( iWriteSettings->connRegainTimerPresent )
+ {
+ err = repository->Set( KWlanConnRegainTimer, static_cast<TInt>( iWriteSettings->connRegainTimer ) );
+
+ if( err == KErrNone )
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams() KWlanConnRegainTimer" );
+ iCallBack->SetStatusL(iWriteStatuses->connRegainTimerStatus, CSmlDmAdapter::EOk);
+ }
+ else
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams() KWlanConnRegainTimer failed" );
+ iCallBack->SetStatusL(iWriteStatuses->connRegainTimerStatus, CSmlDmAdapter::EError);
+ }
+ }
+
+ // Write KWlanMaxTriesToFindNw
+ if ( iWriteSettings->maxTriesToFindNwPresent )
+ {
+ err = repository->Set( KWlanMaxTriesToFindNw, static_cast<TInt>( iWriteSettings->maxTriesToFindNw ) );
+
+ if( err == KErrNone )
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams() KWlanMaxTriesToFindNw ");
+ iCallBack->SetStatusL(iWriteStatuses->maxTriesToFindNwStatus, CSmlDmAdapter::EOk);
+ }
+ else
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams() KWlanMaxTriesToFindNw failed");
+ iCallBack->SetStatusL(iWriteStatuses->maxTriesToFindNwStatus, CSmlDmAdapter::EError);
+ }
+ }
+
+ // Write KWlanDelayBetweenFindNw
+ if ( iWriteSettings->delayBetweenFindNwPresent )
+ {
+ err = repository->Set( KWlanDelayBetweenFindNw, static_cast<TInt>( iWriteSettings->delayBetweenFindNw ) );
+
+ if( err == KErrNone )
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams() KWlanDelayBetweenFindNw" );
+ iCallBack->SetStatusL(iWriteStatuses->delayBetweenFindNwStatus, CSmlDmAdapter::EOk);
+ }
+ else
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams() KWlanDelayBetweenFindNw failed" );
+ iCallBack->SetStatusL(iWriteStatuses->delayBetweenFindNwStatus, CSmlDmAdapter::EError);
+ }
+ }
+
+ // Write KWlanMinPassiveChannelTime
+ if ( iWriteSettings->minPassiveChannelTimePresent )
+ {
+ err = repository->Set( KWlanMinPassiveChannelTime, static_cast<TInt>( iWriteSettings->minPassiveChannelTime ) );
+
+ if( err == KErrNone )
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams() KWlanMinPassiveChannelTime" );
+ iCallBack->SetStatusL(iWriteStatuses->minPassiveChannelTimeStatus, CSmlDmAdapter::EOk);
+ }
+ else
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams() KWlanMinPassiveChannelTime failed" );
+ iCallBack->SetStatusL(iWriteStatuses->minPassiveChannelTimeStatus, CSmlDmAdapter::EError);
+ }
+ }
+
+ // Write KWlanMaxPassiveChannelTime
+ if ( iWriteSettings->maxPassiveChannelTimePresent )
+ {
+ err = repository->Set( KWlanMaxPassiveChannelTime, static_cast<TInt>( iWriteSettings->maxPassiveChannelTime ) );
+
+ if( err == KErrNone )
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams() KWlanMaxPassiveChannelTime" );
+ iCallBack->SetStatusL(iWriteStatuses->maxPassiveChannelTimeStatus, CSmlDmAdapter::EOk);
+ }
+ else
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams() KWlanMaxPassiveChannelTime failed" );
+ iCallBack->SetStatusL(iWriteStatuses->maxPassiveChannelTimeStatus, CSmlDmAdapter::EError);
+ }
+ }
+
+ // Write KWlanMaxApFailureCount
+ if ( iWriteSettings->maxApFailureCountPresent )
+ {
+ err = repository->Set( KWlanMaxApFailureCount, static_cast<TInt>( iWriteSettings->maxApFailureCount ) );
+
+ if( err == KErrNone )
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams() KWlanMaxApFailureCount" );
+ iCallBack->SetStatusL(iWriteStatuses->maxApFailureCountStatus, CSmlDmAdapter::EOk);
+ }
+ else
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams() KWlanMaxApFailureCount failed" );
+ iCallBack->SetStatusL(iWriteStatuses->maxApFailureCountStatus, CSmlDmAdapter::EError);
+ }
+ }
+
+ // Write KWlanLongBeaconFindCount
+ if ( iWriteSettings->longBeaconFindCountPresent )
+ {
+ err = repository->Set( KWlanLongBeaconFindCount, static_cast<TInt>( iWriteSettings->longBeaconFindCount ) );
+
+ if( err == KErrNone )
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams() KWlanLongBeaconFindCount" );
+ iCallBack->SetStatusL(iWriteStatuses->longBeaconFindCountStatus, CSmlDmAdapter::EOk);
+ }
+ else
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams() KWlanLongBeaconFindCount failed" );
+ iCallBack->SetStatusL(iWriteStatuses->longBeaconFindCountStatus, CSmlDmAdapter::EError);
+ }
+ }
+
+ // Write KWlanQosNullFrameInterval
+ if ( iWriteSettings->qosNullFrameIntervalPresent )
+ {
+ err = repository->Set( KWlanQosNullFrameInterval, static_cast<TInt>( iWriteSettings->qosNullFrameInterval ) );
+
+ if( err == KErrNone )
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams() KWlanQosNullFrameInterval" );
+ iCallBack->SetStatusL(iWriteStatuses->qosNullFrameIntervalStatus, CSmlDmAdapter::EOk);
+ }
+ else
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams() KWlanQosNullFrameInterval failed" );
+ iCallBack->SetStatusL(iWriteStatuses->qosNullFrameIntervalStatus, CSmlDmAdapter::EError);
+ }
+ }
+
+ // Write KWlanQosNullFrameTimeout
+ if ( iWriteSettings->qosNullFrameTimeoutPresent )
+ {
+ err = repository->Set( KWlanQosNullFrameTimeout, static_cast<TInt>( iWriteSettings->qosNullFrameTimeout ) );
+
+ if( err == KErrNone )
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams() KWlanQosNullFrameTimeout" );
+ iCallBack->SetStatusL(iWriteStatuses->qosNullFrameTimeoutStatus, CSmlDmAdapter::EOk);
+ }
+ else
+ {
+ _DBG_FILE("CGlobalWLANAdapter:StoreCenRepParams() KWlanQosNullFrameTimeout failed" );
+ iCallBack->SetStatusL(iWriteStatuses->qosNullFrameTimeoutStatus, CSmlDmAdapter::EError);
+ }
+ }
+
+ // Cleanup
+ CleanupStack::PopAndDestroy(repository);
+ _DBG_FILE("CGlobalWLANAdapter::StoreCenRepParams(): end");
+ return;
+ }
+
+// ------------------------------------------------------------------------------------------------
+// void CGlobalWLANAdapter::StoreCommsDBParams( )
+// Stores the parameters to central repository
+// ------------------------------------------------------------------------------------------------
+void CGlobalWLANAdapter::StoreCommsDBParamsL()
+ {
+
+ _DBG_FILE("CGlobalWLANAdapter::StoreCommsDBParams(): begin");
+
+ CCommsDatabase* db = CCommsDatabase::NewL();
+ CleanupStack::PushL(db);
+
+ // User defined WLAN device settings table from Comms database
+ CCommsDbTableView* usrTable;
+
+ // Open user settings.
+ usrTable = db->OpenViewMatchingUintLC( TPtrC(WLAN_DEVICE_SETTINGS),
+ TPtrC(WLAN_DEVICE_SETTINGS_TYPE),
+ KWlanUserSettings );
+
+ // if record did not exist, then it is created.
+ if ( usrTable->GotoFirstRecord() != KErrNone )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::StoreCommsDBParams(): Record creation");
+ TUint32 id;
+ User::LeaveIfError( usrTable->InsertRecord( id ) );
+
+ usrTable->WriteUintL( TPtrC(WLAN_DEVICE_SETTINGS_TYPE), KWlanUserSettings );
+ //usrTable->WriteUintL( TPtrC(WLAN_TABLE_VERSION), KWlanDeviceSettingsTableVersion );
+ User::LeaveIfError( usrTable->PutRecordChanges() ); // End and save changes.
+ }
+
+ // Write CommsDat settings
+ User::LeaveIfError( usrTable->UpdateRecord() ); // Begin changes.
+
+ // Check which parameters are present in the structure, store them into commsdb and
+ // update the status to OK/Error accordingly
+ if ( iWriteSettings->backgroundScanIntervalPresent )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::StoreCommsDBParams(): write KBgScanInterval");
+ TRAPD( err, usrTable->WriteUintL( TPtrC(WLAN_BG_SCAN_INTERVAL), iWriteSettings->backgroundScanInterval ));
+ if ( err == KErrNone)
+ {
+ iCallBack->SetStatusL(iWriteStatuses->backgroundScanIntervalStatus, CSmlDmAdapter::EOk);
+ }
+ else
+ {
+ iCallBack->SetStatusL(iWriteStatuses->backgroundScanIntervalStatus, CSmlDmAdapter::EError);
+ }
+ }
+
+ if ( iWriteSettings->useDefaultSettingsPresent )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::StoreCommsDBParams(): write KUseDefaultSettings");
+ TRAPD( err, usrTable->WriteBoolL( TPtrC(WLAN_USE_DEFAULT_SETTINGS), iWriteSettings->useDefaultSettings ));
+ if ( err == KErrNone)
+ {
+ iCallBack->SetStatusL(iWriteStatuses->useDefaultSettingsStatus, CSmlDmAdapter::EOk);
+ }
+ else
+ {
+ iCallBack->SetStatusL(iWriteStatuses->useDefaultSettingsStatus, CSmlDmAdapter::EError);
+ }
+ }
+
+ if ( iWriteSettings->longRetryLimitPresent )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::StoreCommsDBParams(): write KWlanLongRetry");
+ TRAPD( err, usrTable->WriteUintL( TPtrC(WLAN_LONG_RETRY), iWriteSettings->longRetryLimit ));
+ if ( err == KErrNone)
+ {
+ iCallBack->SetStatusL(iWriteStatuses->longRetryLimitStatus, CSmlDmAdapter::EOk);
+ }
+ else
+ {
+ iCallBack->SetStatusL(iWriteStatuses->longRetryLimitStatus, CSmlDmAdapter::EError);
+ }
+ }
+
+ if ( iWriteSettings->shortRetryLimitPresent )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::StoreCommsDBParams(): write KWlanShortRetry");
+ TRAPD( err, usrTable->WriteUintL( TPtrC(WLAN_SHORT_RETRY), iWriteSettings->shortRetryLimit ));
+ if ( err == KErrNone)
+ {
+ iCallBack->SetStatusL(iWriteStatuses->shortRetryLimitStatus, CSmlDmAdapter::EOk);
+ }
+ else
+ {
+ iCallBack->SetStatusL(iWriteStatuses->shortRetryLimitStatus, CSmlDmAdapter::EError);
+ }
+ }
+
+ if ( iWriteSettings->RTSThresholdPresent )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::StoreCommsDBParams(): write KWlanRTSThreshold");
+ TRAPD( err, usrTable->WriteUintL( TPtrC(WLAN_RTS_THRESHOLD), iWriteSettings->RTSThreshold ));
+ if ( err == KErrNone)
+ {
+ iCallBack->SetStatusL(iWriteStatuses->RTSThresholdStatus, CSmlDmAdapter::EOk);
+ }
+ else
+ {
+ iCallBack->SetStatusL(iWriteStatuses->RTSThresholdStatus, CSmlDmAdapter::EError);
+ }
+ }
+
+ if ( iWriteSettings->TXPowerLevelPresent )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::StoreCommsDBParams(): write KWlanTxPowerLevel");
+ TRAPD( err, usrTable->WriteUintL( TPtrC(NU_WLAN_TX_POWER_LEVEL), iWriteSettings->TXPowerLevel ));
+ if ( err == KErrNone)
+ {
+ iCallBack->SetStatusL(iWriteStatuses->TXPowerLevelStatus, CSmlDmAdapter::EOk);
+ }
+ else
+ {
+ iCallBack->SetStatusL(iWriteStatuses->TXPowerLevelStatus, CSmlDmAdapter::EError);
+ }
+ }
+
+ if ( iWriteSettings->allowRadioMeasurementsPresent )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::StoreCommsDBParams(): write KWlanAllowRadioMeasurements");
+ TRAPD( err, usrTable->WriteBoolL( TPtrC(WLAN_ALLOW_RADIO_MEASUREMENTS), iWriteSettings->allowRadioMeasurements ));
+ if ( err == KErrNone)
+ {
+ iCallBack->SetStatusL(iWriteStatuses->allowRadioMeasurementsStatus, CSmlDmAdapter::EOk);
+ }
+ else
+ {
+ iCallBack->SetStatusL(iWriteStatuses->allowRadioMeasurementsStatus, CSmlDmAdapter::EError);
+ }
+ }
+
+ if ( iWriteSettings->powerSavingPresent )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::StoreCommsDBParams(): write KWlanPowerSaving");
+ TRAPD( err, usrTable->WriteBoolL( TPtrC(WLAN_POWER_MODE), iWriteSettings->powerSaving ));
+ if ( err == KErrNone)
+ {
+ iCallBack->SetStatusL(iWriteStatuses->powerSavingStatus, CSmlDmAdapter::EOk);
+ }
+ else
+ {
+ iCallBack->SetStatusL(iWriteStatuses->powerSavingStatus, CSmlDmAdapter::EError);
+ }
+ }
+
+ _DBG_FILE("CGlobalWLANAdapter::StoreCommsDBParams(): end");
+ User::LeaveIfError( usrTable->PutRecordChanges() ); // End and save changes.
+ CleanupStack::PopAndDestroy( usrTable );
+ CleanupStack::PopAndDestroy( db );
+ return;
+
+ }
+
+
+// ------------------------------------------------------------------------------------------------
+// void CGlobalWLANAdapter::ReadCenRepParams( )
+// Reads parameters from central repository
+// ------------------------------------------------------------------------------------------------
+void CGlobalWLANAdapter::ReadCenRepParamsL()
+ {
+
+ _DBG_FILE("CGlobalWLANAdapter::ReadCenRepParams(): begin");
+
+ TInt err = KErrNone;
+ CRepository* repository = NULL;
+ TBuf8<KInputMaxLength> value;
+ TBuf8<KTypeMaxLength> type;
+ TInt temp = 0;
+
+ // InternetConnectivityTest parameter is in a different cenRep than the other parameters
+ // Write KWlanScanRate
+ if ( iReadSettings->internetConnectivityTestPresent )
+ {
+ // This parameter is in the internet connectivity settings cenRep, open the repository
+ repository = CRepository::NewL( KCRUidInternetConnectivitySettings );
+ CleanupStack::PushL(repository);
+
+ value.Zero();
+ type.Zero();
+
+ // if opening the cenrtral repository failed, then leave this function
+ if ( repository == NULL )
+ {
+ User::LeaveIfError( KErrGeneral );
+ }
+
+ err = repository->Get( KIctsTestPermission, temp );
+ value.Num(temp);
+ type.Append( KNSmlWLanInternetConnectivityTest );
+ UpdateStatusAndResultL( iReadStatuses->internetConnectivityTestResult, iReadStatuses->internetConnectivityTestStatus,
+ value, type, err );
+
+ CleanupStack::PopAndDestroy(repository);
+ }
+
+ // The rest of the parameters are in WlanDeviceSettings cenRep
+ repository = CRepository::NewL( KCRUidWlanDeviceSettingsRegistryId );
+ CleanupStack::PushL(repository);
+
+ // if opening the cenrtral repository failed, then leave this function
+ if ( repository == NULL )
+ {
+ User::LeaveIfError( KErrGeneral );
+ }
+
+ if ( iReadSettings->MTUPresent )
+ {
+ value.Zero();
+ type.Zero();
+ err = repository->Get( KWlanMTU, temp );
+ value.Num(temp);
+ type.Append( KNSmlWLanMTU );
+ UpdateStatusAndResultL( iReadStatuses->MTUResult, iReadStatuses->MTUStatus,
+ value, type, err );
+ }
+
+ // Write KWlanScanRate
+ if ( iReadSettings->scanRatePresent )
+ {
+ value.Zero();
+ type.Zero();
+ err = repository->Get( KWlanScanRate, temp );
+ value.Num(temp);
+ type.Append( KNSmlWLanScanRate );
+ UpdateStatusAndResultL( iReadStatuses->scanRateResult, iReadStatuses->scanRateStatus,
+ value, type, err );
+ }
+
+ // Write KWlanRcpiTrigger
+ if ( iReadSettings->RCPITriggerPresent )
+ {
+ value.Zero();
+ type.Zero();
+ err = repository->Get( KWlanRcpiTrigger, temp );
+ value.Num(temp);
+ type.Append( KNSmlWLanRCPITrigger );
+ UpdateStatusAndResultL( iReadStatuses->RCPITriggerResult, iReadStatuses->RCPITriggerStatus,
+ value, type, err );
+ }
+
+ // Write KWlanMinActiveChannelTime
+ if ( iReadSettings->minActiveChannelTimePresent )
+ {
+ value.Zero();
+ type.Zero();
+ err = repository->Get( KWlanMinActiveChannelTime, temp );
+ value.Num(temp);
+ type.Append( KNSmlWLanMinActiveChannelTime );
+ UpdateStatusAndResultL( iReadStatuses->minActiveChannelTimeResult, iReadStatuses->minActiveChannelTimeStatus,
+ value, type, err );
+ }
+
+ // Write KWlanMaxActiveChannelTime
+ if ( iReadSettings->maxActiveChannelTimePresent )
+ {
+ value.Zero();
+ type.Zero();
+ err = repository->Get( KWlanMaxActiveChannelTime, temp );
+ value.Num(temp);
+ type.Append( KNSmlWLanMaxActiveChannelTime );
+ UpdateStatusAndResultL( iReadStatuses->maxActiveChannelTimeResult, iReadStatuses->maxActiveChannelTimeStatus,
+ value, type, err );
+ }
+
+ // Write KWlanMaxTxMSDULifeTime
+ if ( iReadSettings->maxTxMSDULifeTimePresent )
+ {
+ value.Zero();
+ type.Zero();
+ err = repository->Get( KWlanMaxTxMSDULifeTime, temp );
+ value.Num(temp);
+ type.Append( KNSmlWLanMaxTxMSDULifeTime );
+ UpdateStatusAndResultL( iReadStatuses->maxTxMSDULifeTimeResult, iReadStatuses->maxTxMSDULifeTimeStatus,
+ value, type, err );
+ }
+
+ // Write KWlanScanExpirationTimer
+ if ( iReadSettings->scanExpirationTimerPresent )
+ {
+ value.Zero();
+ type.Zero();
+ err = repository->Get( KWlanScanExpirationTimer, temp );
+ value.Num(temp);
+ type.Append( KNSmlWLanScanExpirationTimer );
+ UpdateStatusAndResultL( iReadStatuses->scanExpirationTimerResult, iReadStatuses->scanExpirationTimerStatus,
+ value, type, err );
+ }
+
+ // Write KWlanUnloadDriverTimer
+ if ( iReadSettings->unloadDriverTimerPresent )
+ {
+ value.Zero();
+ type.Zero();
+ err = repository->Get( KWlanUnloadDriverTimer, temp );
+ value.Num(temp);
+ type.Append( KNSmlWLanUnloadDriverTimer );
+ UpdateStatusAndResultL( iReadStatuses->unloadDriverTimerResult, iReadStatuses->unloadDriverTimerStatus,
+ value, type, err );
+ }
+
+ // Write KWlanRoamTimer
+ if ( iReadSettings->roamTimerPresent )
+ {
+ value.Zero();
+ type.Zero();
+ err = repository->Get( KWlanRoamTimer, temp );
+ value.Num(temp);
+ type.Append( KNSmlWLanRoamTimer );
+ UpdateStatusAndResultL( iReadStatuses->roamTimerResult, iReadStatuses->roamTimerStatus,
+ value, type, err );
+ }
+
+ // Write KWlanRcpiDifference
+ if ( iReadSettings->RCPIDifferencePresent )
+ {
+ value.Zero();
+ type.Zero();
+ type.Append( KNSmlWLanRCPIDifference );
+ err = repository->Get( KWlanRcpiDifference, temp );
+ value.Num(temp);
+ UpdateStatusAndResultL( iReadStatuses->RCPIDifferenceResult, iReadStatuses->RCPIDifferenceStatus,
+ value, type, err );
+ }
+
+ // Write KWlanConnRegainTimer
+ if ( iReadSettings->connRegainTimerPresent )
+ {
+ value.Zero();
+ type.Zero();
+ type.Append( KNSmlWLanConnRegainTimer );
+ err = repository->Get( KWlanConnRegainTimer, temp );
+ value.Num(temp);
+ UpdateStatusAndResultL( iReadStatuses->connRegainTimerResult, iReadStatuses->connRegainTimerStatus,
+ value, type, err );
+ }
+
+ // Write KWlanMaxTriesToFindNw
+ if ( iReadSettings->maxTriesToFindNwPresent )
+ {
+ value.Zero();
+ type.Zero();
+ err = repository->Get( KWlanMaxTriesToFindNw, temp );
+ value.Num(temp);
+ type.Append( KNSmlWLanMaxTriesToFindNw );
+ UpdateStatusAndResultL( iReadStatuses->maxTriesToFindNwResult, iReadStatuses->maxTriesToFindNwStatus,
+ value, type, err );
+ }
+
+ // Write KWlanDelayBetweenFindNw
+ if ( iReadSettings->delayBetweenFindNwPresent )
+ {
+ value.Zero();
+ type.Zero();
+ err = repository->Get( KWlanDelayBetweenFindNw, temp );
+ value.Num(temp);
+ type.Append( KNSmlWLanDelayBetweenFindNw );
+ UpdateStatusAndResultL( iReadStatuses->delayBetweenFindNwResult, iReadStatuses->delayBetweenFindNwStatus,
+ value, type, err );
+ }
+
+ // Write KWlanMinPassiveChannelTime
+ if ( iReadSettings->minPassiveChannelTimePresent )
+ {
+ value.Zero();
+ type.Zero();
+ err = repository->Get( KWlanMinPassiveChannelTime, temp );
+ value.Num(temp);
+ type.Append( KNSmlWLanRCPITrigger );
+ UpdateStatusAndResultL( iReadStatuses->minPassiveChannelTimeResult, iReadStatuses->minPassiveChannelTimeStatus,
+ value, type, err );
+ }
+
+ // Write KWlanMaxPassiveChannelTime
+ if ( iReadSettings->maxPassiveChannelTimePresent )
+ {
+ value.Zero();
+ type.Zero();
+ err = repository->Get( KWlanMaxPassiveChannelTime, temp );
+ value.Num(temp);
+ type.Append( KNSmlWLanMinPassiveChannelTime );
+ UpdateStatusAndResultL( iReadStatuses->maxPassiveChannelTimeResult, iReadStatuses->maxPassiveChannelTimeStatus,
+ value, type, err );
+ }
+
+ // Write KWlanMaxApFailureCount
+ if ( iReadSettings->maxApFailureCountPresent )
+ {
+ value.Zero();
+ type.Zero();
+ err = repository->Get( KWlanMaxApFailureCount, temp );
+ value.Num(temp);
+ type.Append( KNSmlWLanMaxApFailureCount );
+ UpdateStatusAndResultL( iReadStatuses->maxApFailureCountResult, iReadStatuses->maxApFailureCountStatus,
+ value, type, err );
+ }
+
+ // Write KWlanLongBeaconFindCount
+ if ( iReadSettings->longBeaconFindCountPresent )
+ {
+ value.Zero();
+ type.Zero();
+ err = repository->Get( KWlanLongBeaconFindCount, temp );
+ value.Num(temp);
+ type.Append( KNSmlWLanLongBeaconFindCount );
+ UpdateStatusAndResultL( iReadStatuses->longBeaconFindCountResult, iReadStatuses->longBeaconFindCountStatus,
+ value, type, err );
+ }
+
+ // Write KWlanQosNullFrameInterval
+ if ( iReadSettings->qosNullFrameIntervalPresent )
+ {
+ value.Zero();
+ type.Zero();
+ err = repository->Get( KWlanQosNullFrameInterval, temp );
+ value.Num(temp);
+ type.Append( KNSmlWLanQosNullFrameInterval );
+ UpdateStatusAndResultL( iReadStatuses->qosNullFrameIntervalResult, iReadStatuses->qosNullFrameIntervalStatus,
+ value, type, err );
+ }
+
+ // Write KWlanQosNullFrameTimeout
+ if ( iReadSettings->qosNullFrameTimeoutPresent )
+ {
+ value.Zero();
+ type.Zero();
+ err = repository->Get( KWlanQosNullFrameTimeout, temp );
+ value.Num(temp);
+ type.Append( KNSmlWLanQosNullFrameTimeout );
+ UpdateStatusAndResultL( iReadStatuses->qosNullFrameTimeoutResult, iReadStatuses->qosNullFrameTimeoutStatus,
+ value, type, err );
+ }
+
+ // Cleanup
+ CleanupStack::PopAndDestroy(repository);
+ _DBG_FILE("CGlobalWLANAdapter::ReadCenRepParams(): end");
+ return;
+
+ }
+
+// ------------------------------------------------------------------------------------------------
+// void CGlobalWLANAdapter::UpdateStatusAndResultL( )
+// Reads parameters from cenrep and updates result/status
+// ------------------------------------------------------------------------------------------------
+void CGlobalWLANAdapter::UpdateStatusAndResultL( TInt aResult, TInt aStatus, TDesC8& aValue, TDesC8& aType, TInt aStoreErr )
+ {
+
+ _DBG_FILE("CGlobalWLANAdapter::UpdateStatusAndResultL(): begin");
+
+ CBufBase *lObject = CBufFlat::NewL(KInputMaxLength);
+ CleanupStack::PushL(lObject);
+
+ // If reading went ok, then we can set the results and statuses
+ if ( aStoreErr == KErrNone )
+ {
+ lObject->InsertL(0, aValue);
+ iCallBack->SetResultsL( aResult,*lObject,aType );
+ iCallBack->SetStatusL( aStatus, CSmlDmAdapter::EOk);
+ }
+ else
+ {
+ iCallBack->SetStatusL( aStatus, CSmlDmAdapter::EError );
+ }
+
+ _DBG_FILE("CGlobalWLANAdapter::UpdateStatusAndResultL(): end");
+ CleanupStack::PopAndDestroy(lObject);
+ return;
+ }
+
+// ------------------------------------------------------------------------------------------------
+// void CGlobalWLANAdapter::ReadCommsDBParams( )
+// Reads parameters from commsDB
+// ------------------------------------------------------------------------------------------------
+void CGlobalWLANAdapter::ReadCommsDBParamsL()
+ {
+ _DBG_FILE("CGlobalWLANAdapter::ReadCommsDBParams() begin" );
+
+ CCommsDatabase* db = CCommsDatabase::NewL();
+ CleanupStack::PushL(db);
+
+ // User defined WLAN device settings table from Comms database
+ CCommsDbTableView* usrTable;
+
+ // Open user settings.
+ usrTable = db->OpenViewMatchingUintLC( TPtrC(WLAN_DEVICE_SETTINGS),
+ TPtrC(WLAN_DEVICE_SETTINGS_TYPE),
+ KWlanUserSettings );
+
+ TUint32 intVal;
+ TBool boolVal = EFalse;
+ TBuf8<KInputMaxLength> value;
+ TBuf8<KTypeMaxLength> type;
+ TInt err = KErrNone;
+ TInt readErr = KErrNone;
+ _LIT8(KTrue,"True");
+ _LIT8(KFalse,"False");
+
+ // if record did not exist, then we don't do anything
+ if ( usrTable == NULL )
+ readErr = KErrGeneral;
+ else
+ readErr = usrTable->GotoFirstRecord();
+
+ // Check whether parameter was requested to be fetched
+ if ( iReadSettings->backgroundScanIntervalPresent )
+ {
+ // The reading is done if the commdb record was opened successfully, otherwise the err
+ // is updated so that the ReadAndSetStatus function can update thet status correctly
+ if ( readErr == KErrNone )
+ {
+ TRAP( err, usrTable->ReadUintL( TPtrC(WLAN_BG_SCAN_INTERVAL), intVal ));
+ }
+ else
+ {
+ err=readErr;
+ }
+
+ value.Zero();
+ type.Zero();
+ value.Num(intVal);
+ type.Append( KNSmlWLanBackgroundScanInterval );
+ UpdateStatusAndResultL( iReadStatuses->backgroundScanIntervalResult, iReadStatuses->backgroundScanIntervalStatus,
+ value, type, err );
+ }
+
+ if ( iReadSettings->useDefaultSettingsPresent )
+ {
+ if ( readErr == KErrNone )
+ {
+ TRAP( err, usrTable->ReadBoolL( TPtrC(WLAN_USE_DEFAULT_SETTINGS), boolVal ));
+ }
+ else
+ {
+ err=readErr;
+ }
+
+ value.Zero();
+ type.Zero();
+ if ( boolVal == 0 )
+ value.Copy(KFalse);
+ else
+ value.Copy(KTrue);
+
+ type.Append( KNSmlWLanUseDefaultSettings );
+ _DBG_FILE("CGlobalWLANAdapter::ReadCommsDBParams() go set status" );
+ UpdateStatusAndResultL( iReadStatuses->useDefaultSettingsResult, iReadStatuses->useDefaultSettingsStatus,
+ value, type, err );
+ }
+
+ if ( iReadSettings->longRetryLimitPresent )
+ {
+ if ( readErr == KErrNone )
+ {
+ TRAP( err, usrTable->ReadUintL( TPtrC(WLAN_LONG_RETRY), intVal ));
+ }
+ else
+ {
+ err = readErr;
+ }
+
+ value.Zero();
+ value.Num(intVal);
+ type.Zero();
+ type.Append( KNSmlWLanLongRetryLimit );
+ UpdateStatusAndResultL( iReadStatuses->longRetryLimitResult, iReadStatuses->longRetryLimitStatus,
+ value, type, err );
+ }
+
+ if ( iReadSettings->shortRetryLimitPresent )
+ {
+ if ( readErr == KErrNone )
+ {
+ TRAP( err, usrTable->ReadUintL( TPtrC(WLAN_SHORT_RETRY), intVal ));
+ }
+ else
+ {
+ err = readErr;
+ }
+
+ value.Zero();
+ type.Zero();
+ value.Num(intVal);
+ type.Append( KNSmlWLanShortRetryLimit );
+ UpdateStatusAndResultL( iReadStatuses->shortRetryLimitResult, iReadStatuses->shortRetryLimitStatus,
+ value, type, err );
+ }
+
+ if ( iReadSettings->RTSThresholdPresent )
+ {
+ if ( readErr == KErrNone )
+ {
+ TRAP( err, usrTable->ReadUintL( TPtrC(WLAN_RTS_THRESHOLD), intVal ));
+ }
+ else
+ {
+ err = readErr;
+ }
+
+ value.Zero();
+ type.Zero();
+ value.Num(intVal);
+ type.Append( KNSmlWLanRTSThreshold );
+ UpdateStatusAndResultL( iReadStatuses->RTSThresholdResult, iReadStatuses->RTSThresholdStatus,
+ value, type, err );
+ }
+
+ if ( iReadSettings->TXPowerLevelPresent )
+ {
+ if ( readErr == KErrNone )
+ {
+ TRAP( err, usrTable->ReadUintL( TPtrC(NU_WLAN_TX_POWER_LEVEL), intVal ));
+ }
+ else
+ {
+ err = readErr;
+ }
+
+ value.Zero();
+ type.Zero();
+ value.Num(intVal);
+ type.Append( KNSmlWLanTXPowerLevel );
+ UpdateStatusAndResultL( iReadStatuses->TXPowerLevelResult, iReadStatuses->TXPowerLevelStatus,
+ value, type, err );
+ }
+
+ if ( iReadSettings->allowRadioMeasurementsPresent )
+ {
+ if ( readErr == KErrNone )
+ {
+ TRAP( err, usrTable->ReadBoolL( TPtrC(WLAN_ALLOW_RADIO_MEASUREMENTS), boolVal ));
+ }
+ else
+ {
+ err = readErr;
+ }
+
+ value.Zero();
+ type.Zero();
+ if ( boolVal )
+ value.Copy(_L8("True"));
+ else
+ value.Copy(_L8("False"));
+
+ type.Append( KNSmlWLanAllowRadioMeasurements );
+ UpdateStatusAndResultL( iReadStatuses->allowRadioMeasurementsResult, iReadStatuses->allowRadioMeasurementsStatus,
+ value, type, err );
+ }
+
+ if ( iReadSettings->powerSavingPresent )
+ {
+ if ( readErr == KErrNone )
+ {
+ TRAP( err, usrTable->ReadBoolL( TPtrC(WLAN_POWER_MODE), boolVal ));
+ }
+ else
+ {
+ err = readErr;
+ }
+
+ value.Zero();
+ type.Zero();
+ if ( boolVal )
+ value.Copy(_L8("True"));
+ else
+ value.Copy(_L8("False"));
+
+ type.Append( KNSmlWLanPowerSaving );
+ UpdateStatusAndResultL( iReadStatuses->powerSavingResult, iReadStatuses->powerSavingStatus,
+ value, type, err );
+ }
+
+ CleanupStack::PopAndDestroy( usrTable );
+ CleanupStack::PopAndDestroy( db );
+ _DBG_FILE("CGlobalWLANAdapter::ReadCommsDBParams() end" );
+ return;
+ }
+
+
+
+// ------------------------------------------------------------------------------------------------
+// TInt CGlobalWLANAdapter::NumOfUriSegs( const TDesC8& aUri )
+// Return count of URI segments of aUri
+// ------------------------------------------------------------------------------------------------
+TInt CGlobalWLANAdapter::NumOfUriSegs( const TDesC8& aUri )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::NumOfUriSegs(): begin");
+
+ TInt count = 1;
+ for( TInt i=0; i<aUri.Length(); i++ )
+ {
+ if( aUri[i] == '/' )
+ count ++;
+ }
+
+ _DBG_FILE("CGlobalWLANAdapter::NumOfUriSegs(): end");
+ return count;
+ }
+
+
+// ------------------------------------------------------------------------------------------------
+// TPtrC8 CGlobalWLANAdapter::GetLastUriSeg(const TDesC8& aURI)
+// Returns only the last uri segemnt
+// ------------------------------------------------------------------------------------------------
+TPtrC8 CGlobalWLANAdapter::GetLastUriSeg( const TDesC8& aURI )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::GetLastUriSeg(): begin");
+
+ // search for the segment after the last slash
+ TInt i;
+ for( i = aURI.Length() - 1; i >= 0; i-- )
+ {
+ if( aURI[i] == '/' )
+ {
+ break;
+ }
+ }
+
+ if( i == 0 )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::GetLastUriSeg(): end");
+ return aURI;
+ }
+ else
+ {
+ _DBG_FILE("CGlobalWLANAdapter::GetLastUriSeg(): end");
+ return aURI.Mid( i + 1 );
+ }
+ }
+
+
+// ------------------------------------------------------------------------------------------------
+// TInt CNSmlWLanAdapter::DesToInt( const TDesC8& aNumber )
+// Returns aLuid as integer value
+// ------------------------------------------------------------------------------------------------
+TInt CGlobalWLANAdapter::DesToInt( const TDesC8& aNumber )
+ {
+ _DBG_FILE("CGlobalWLANAdapter::DesToInt(): begin");
+
+ TInt err = KErrNone;
+ TLex8 lex(aNumber);
+ TInt value = 0;
+ err = lex.Val( value );
+
+ DBG_ARGS8(_S8("CGlobalWLANAdapter::DesToInt() - Des: <%S> Int: <%D>"), &aNumber, value );
+ _DBG_FILE("CGlobalWLANAdapter::DesToInt(): end");
+
+ // the input might have been illegal. Return error code if conversion failed.
+ if ( err == KErrNone )
+ return value;
+ else
+ return err;
+ }
+
+
+// ------------------------------------------------------------------------------------------------
+// TInt CNSmlWLanAdapter::InitMemberVariables
+// Inits the member variable structures
+// ------------------------------------------------------------------------------------------------
+void CGlobalWLANAdapter::InitMemberVariables()
+ {
+ _DBG_FILE("CGlobalWLANAdapter::InitMemberVariables(): begin");
+
+ iWriteSettings->RCPITriggerPresent=EFalse;
+ iWriteSettings->internetConnectivityTestPresent=EFalse;
+ iWriteSettings->useDefaultSettingsPresent=EFalse;
+ iWriteSettings->longRetryLimitPresent=EFalse;
+ iWriteSettings->shortRetryLimitPresent=EFalse;
+ iWriteSettings->RTSThresholdPresent=EFalse;
+ iWriteSettings->TXPowerLevelPresent=EFalse;
+ iWriteSettings->powerSavingPresent=EFalse;
+ iWriteSettings->backgroundScanIntervalPresent=EFalse;
+ iWriteSettings->scanRatePresent=EFalse;
+ iWriteSettings->RCPITriggerPresent=EFalse;
+ iWriteSettings->minActiveChannelTimePresent=EFalse;
+ iWriteSettings->maxActiveChannelTimePresent=EFalse;
+ iWriteSettings->maxTxMSDULifeTimePresent=EFalse;
+ iWriteSettings->scanExpirationTimerPresent=EFalse;
+ iWriteSettings->unloadDriverTimerPresent=EFalse;
+ iWriteSettings->roamTimerPresent=EFalse;
+ iWriteSettings->RCPIDifferencePresent=EFalse;
+ iWriteSettings->connRegainTimerPresent=EFalse;
+ iWriteSettings->maxTriesToFindNwPresent=EFalse;
+ iWriteSettings->delayBetweenFindNwPresent=EFalse;
+ iWriteSettings->allowRadioMeasurementsPresent=EFalse;
+ iWriteSettings->minPassiveChannelTimePresent=EFalse;
+ iWriteSettings->maxPassiveChannelTimePresent=EFalse;
+ iWriteSettings->maxApFailureCountPresent=EFalse;
+ iWriteSettings->longBeaconFindCountPresent=EFalse;
+ iWriteSettings->qosNullFrameIntervalPresent=EFalse;
+ iWriteSettings->qosNullFrameTimeoutPresent=EFalse;
+ iWriteSettings->MTUPresent=EFalse;
+
+ iReadSettings->RCPITriggerPresent=EFalse;
+ iReadSettings->internetConnectivityTestPresent=EFalse;
+ iReadSettings->useDefaultSettingsPresent=EFalse;
+ iReadSettings->longRetryLimitPresent=EFalse;
+ iReadSettings->shortRetryLimitPresent=EFalse;
+ iReadSettings->RTSThresholdPresent=EFalse;
+ iReadSettings->TXPowerLevelPresent=EFalse;
+ iReadSettings->powerSavingPresent=EFalse;
+ iReadSettings->backgroundScanIntervalPresent=EFalse;
+ iReadSettings->scanRatePresent=EFalse;
+ iReadSettings->RCPITriggerPresent=EFalse;
+ iReadSettings->minActiveChannelTimePresent=EFalse;
+ iReadSettings->maxActiveChannelTimePresent=EFalse;
+ iReadSettings->maxTxMSDULifeTimePresent=EFalse;
+ iReadSettings->scanExpirationTimerPresent=EFalse;
+ iReadSettings->unloadDriverTimerPresent=EFalse;
+ iReadSettings->roamTimerPresent=EFalse;
+ iReadSettings->RCPIDifferencePresent=EFalse;
+ iReadSettings->connRegainTimerPresent=EFalse;
+ iReadSettings->maxTriesToFindNwPresent=EFalse;
+ iReadSettings->delayBetweenFindNwPresent=EFalse;
+ iReadSettings->allowRadioMeasurementsPresent=EFalse;
+ iReadSettings->minPassiveChannelTimePresent=EFalse;
+ iReadSettings->maxPassiveChannelTimePresent=EFalse;
+ iReadSettings->maxApFailureCountPresent=EFalse;
+ iReadSettings->longBeaconFindCountPresent=EFalse;
+ iReadSettings->qosNullFrameIntervalPresent=EFalse;
+ iReadSettings->qosNullFrameTimeoutPresent=EFalse;
+ iReadSettings->MTUPresent=EFalse;
+
+ _DBG_FILE("CGlobalWLANAdapter::InitMemberVariables(): begin");
+ }
+
+// end of file