1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

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

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Interface to read and write WLAN device specific settings.

    15 *

    16 */

    17 

    18 /*

    19 * %version: 17 %

    20 */

    21 

    22 // INCLUDE FILES

    23 #include <commdb.h>

    24 #include <centralrepository.h>

    25 #include <commsdattypesv1_1.h>

    26 #include <e32std.h>

    27 

    28 #include "am_debug.h"

    29 #include "wlandevicesettings.h"

    30 #include "wlandevicesettingsprivatecrkeys.h"

    31 

    32 // CONSTANTS

    33 // Ids for Wlan settings type.

    34 const TUint32 KWlanDefaultSettings            = 0;

    35 const TUint32 KWlanUserSettings               = 1;

    36 const TUint32 KMaxCommsDbWriteAttempts        = 10;

    37 const TUint32 KRetryIntervalUsIfCommsDbLocked = 100000;

    38 

    39 // Table name

    40 _LIT( KWlanDeviceSettings,          "WLANDeviceTable" );

    41 _LIT( KTableVersion,                "Version");

    42 _LIT( KWlanDeviceSettingsType,      "WlanDeviceSettingsType" );

    43 _LIT( KBgScanInterval,              "WlanBgScanInterval" );

    44 _LIT( KUseDefaultSettings,          "WlanUseDefaultSettings" );

    45 _LIT( KWlanLongRetry,               "WlanLongRetry" );

    46 _LIT( KWlanRTSThreshold,            "WlanRTS" );

    47 _LIT( KWlanShortRetry,              "WlanShortRetry" );

    48 _LIT( KWlanTxPowerLevel,            "WlanTxPowerLevel" );

    49 _LIT( KWlanAllowRadioMeasurements,  "AllowRadioMeasurements" );

    50 _LIT( KWlanPowerMode,               "WlanPowerMode" );

    51 

    52 // Increase version every time the content of the table changes!

    53 const TUint32 KWlanDeviceSettingsTableVersion = 9;

    54 

    55 // LOCAL FUNCTION PROTOTYPES

    56 

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

    58 

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

    60 

    61 // ---------------------------------------------------------

    62 // CWlanDeviceSettings::CWlanDeviceSettings

    63 // NOTE! This class is derived from CBase, so, it is

    64 //       initialised with zero. The initialisation of its

    65 //       attributes is unnecessary.

    66 // ---------------------------------------------------------

    67 //

    68 CWlanDeviceSettings::CWlanDeviceSettings()

    69     {

    70     } 

    71 

    72 // ---------------------------------------------------------

    73 // CWlanDeviceSettings::ConstructL

    74 // ---------------------------------------------------------

    75 //

    76 void CWlanDeviceSettings::ConstructL()

    77     {

    78     DEBUG( "CWlanDeviceSettings::ConstructL()" );

    79     // Open the CommsDB.

    80     iDb = CCommsDatabase::NewL();

    81 

    82     // Check that the version of WlanDeviceSettings is correct.

    83     TRAPD( err, CheckWlanDeviceSettingsTableL() );

    84 

    85     if ( err != KErrNone )

    86         {

    87         // Okay, the version is not correct or the table is not found.

    88         DEBUG( "ERROR: SETTINGS NOT OK!!" );

    89         delete iDb;

    90         iDb = NULL;

    91         User::Leave( err );

    92         }

    93 

    94     // Open the WLAN device settings table.

    95     OpenTableL();

    96     DEBUG( "CWlanDeviceSettings::ConstructL() Tables opened ok." );

    97     }

    98 

    99 // ---------------------------------------------------------

   100 // CWlanDeviceSettings::NewL

   101 // ---------------------------------------------------------

   102 //

   103 EXPORT_C CWlanDeviceSettings* CWlanDeviceSettings::NewL()

   104     {

   105     DEBUG( "CWlanDeviceSettings::NewL()" );

   106 

   107     CWlanDeviceSettings* self = new (ELeave) CWlanDeviceSettings;

   108     CleanupStack::PushL( self );

   109     self->ConstructL();

   110     CleanupStack::Pop( self );

   111     return self;

   112     }

   113 

   114 // ---------------------------------------------------------

   115 // CWlanDeviceSettings::~CWlanDeviceSettings

   116 // ---------------------------------------------------------

   117 //

   118 EXPORT_C CWlanDeviceSettings::~CWlanDeviceSettings()

   119     {

   120     DEBUG( "CWlanDeviceSettings::~CWlanDeviceSettings()" );

   121     delete iDefTable;

   122     delete iUsrTable;

   123     delete iDb;

   124     }

   125 

   126 // ---------------------------------------------------------

   127 // CWlanDeviceSettings::GetDefaultSettings

   128 // ---------------------------------------------------------

   129 //

   130 EXPORT_C void CWlanDeviceSettings::GetDefaultSettings( 

   131     SWlanDeviceSettings& aSettings )

   132     {

   133     DEBUG( "CWlanDeviceSettings::GetDefaultSettings()" );

   134 

   135     aSettings.beacon = KWlanDefaultBeacon;

   136     aSettings.longRetry = KWlanDefaultLongRetryLimit;

   137     aSettings.rts = KWlanDefaultRTSThreshold;

   138     aSettings.shortRetry = KWlanDefaultShortRetryLimit;

   139     aSettings.backgroundScanInterval = KWlanDefaultBackgroundScanInterval;

   140     aSettings.txPowerLevel = KWlanDefaultTxPowerLevel;

   141     aSettings.scanRate = E1Mbps;

   142     aSettings.rcpiTrigger = KWlanDefaultRcpiTrigger;

   143     aSettings.minActiveChannelTime = KWlanDefaultMinChanneltime;

   144     aSettings.maxActiveChannelTime = KWlanDefaultMaxChanneltime;

   145     aSettings.maxTxMSDULifeTime = KWlanDefaultMaxTransmitMSDULifetime;

   146     aSettings.useDefaultSettings = ETrue;		

   147     aSettings.scanExpirationTimer = KWlanDefaultScanExpirationTimer;

   148     aSettings.unloadDriverTimer = KWlanDefaultUnloadDriverTimer;

   149     aSettings.roamTimer = KWlanDefaultRoamTimer;

   150     aSettings.rcpiDifference = KWlanDefaultRcpiDifference;

   151     aSettings.connRegainTimer = KWlanDefaultConnRegainTimer;

   152     aSettings.maxTriesToFindNw = KWlanDefaultMaxTriesToFindNw;

   153     aSettings.delayBetweenFindNw = KWlanDefaultDelayBetweenFindNw;

   154     aSettings.powerMode = KWlanDefaultowerMode;

   155     aSettings.allowRadioMeasurements = ETrue;

   156     aSettings.minPassiveChannelTime = KWlanDefaultMinPassiveChannelTime;

   157     aSettings.maxPassiveChannelTime = KWlanDefaultMaxPassiveChannelTime;

   158     aSettings.maxApFailureCount = KWlanDefaultMaxApFailureCount;

   159     aSettings.maxApAuthFailureCount = KWlanDefaultMaxApAuthFailureCount;

   160     aSettings.longBeaconFindCount = KWlanDefaultLongBeaconFindCount;

   161     aSettings.qosNullFrameInterval = KWlanDefaultQosNullFrameInterval;

   162     aSettings.qosNullFrameTimeout = KWlanDefaultQosNullFrameTimeout;

   163     aSettings.keepAliveInterval = KWlanDefaultKeepAliveInterval;          

   164     aSettings.scanStopRcpiThreshold = KWlanDefaultScanStopRcpiThreshold;      

   165     aSettings.minRcpiForIapAvailability = KWlanDefaultMinRcpiForIapAvailability;  

   166     aSettings.qosNullFrameEntryTimeout = KWlanDefaultQoSNullFrameEntryTimeout;   

   167     aSettings.maxApDeauthenticationCount = KWlanDefaultMaxApDeauthenticationCount; 

   168     aSettings.apDeauthenticationTimeout = KWlanDefaultApDeauthenticationTimeout;  

   169     aSettings.showBrokenPowerSaveNote = ETrue;

   170     aSettings.maxDtimSkipInterval = KWlanDefaultMaxDtimSkipInterval;

   171     aSettings.psActiveToLightTimeout = KWlanDefaultPsActiveToLightTimeout;

   172     aSettings.psActiveToLightThreshold = KWlanDefaultPsActiveToLightThreshold;

   173     aSettings.psLightToActiveTimeout = KWlanDefaultPsLightToActiveTimeout;

   174     aSettings.psLightToActiveThreshold = KWlanDefaultPsLightToActiveThreshold;

   175     aSettings.psLightToDeepTimeout = KWlanDefaultPsLightToDeepTimeout;

   176     aSettings.psLightToDeepThreshold = KWlanDefaultPsLightToDeepThreshold;

   177     aSettings.psUapsdRxThreshold = KWlanDefaultPsUapsdRxFrameLengthThreshold;    

   178     aSettings.rcpiRoamMinInterval = KWlanDefaultRcpiRoamMinInterval;

   179     aSettings.rcpiRoamMaxInterval = KWlanDefaultRcpiRoamMaxInterval;

   180     aSettings.rcpiRoamAttemptsPerInterval = KWlanDefaultRcpiRoamAttemptsPerInterval;

   181     aSettings.rcpiRoamNextIntervalFactor = KWlanDefaultRcpiRoamNextIntervalFactor;

   182     aSettings.rcpiRoamNextIntervalAddition = KWlanDefaultRcpiRoamNextIntervalAddition;

   183     aSettings.scanListExpirationTime = KWlanDefaultScanListExpirationTime;

   184     aSettings.qosNullFrameEntryTxCount = KWlanDefaultQoSNullFrameEntryTxCount;

   185     aSettings.spRcpiTarget = KWlanDefaultSpRcpiTarget;

   186     aSettings.spTimeTarget = KWlanDefaultSpTimeTarget;

   187     aSettings.spMinIndicationInterval = KWlanDefaultSpMinIndicationInterval;

   188     aSettings.bssLostRoamMinInterval = KWlanDefaultBssLostRoamMinInterval;

   189     aSettings.bssLostRoamMaxInterval = KWlanDefaultBssLostRoamMaxInterval;

   190     aSettings.bssLostRoamAttemptsPerInterval = KWlanDefaultBssLostRoamAttemptsPerInterval;

   191     aSettings.bssLostRoamNextIntervalFactor = KWlanDefaultBssLostRoamNextIntervalFactor;

   192     aSettings.bssLostRoamNextIntervalAddition = KWlanDefaultBssLostRoamNextIntervalAddition;

   193     aSettings.bssLostRoamMaxTriesToFindNw = KWlanDefaultBssLostRoamMaxTriesToFindNw;

   194     aSettings.trafficStreamCreationTimeout = KWlanDefaultTrafficStreamCreationTimeout;

   195     aSettings.beaconLostThreshold = KWlanDefaultBeaconLostThreshold;

   196     aSettings.btBeaconLostThreshold = KWlanDefaultBtBeaconLostThreshold;

   197     aSettings.txFailThreshold = KWlanDefaultTxFailThreshold;

   198     aSettings.btTxFailThreshold = KWlanDefaultBtTxFailThreshold;

   199     aSettings.powerSaveDelay = KWlanDefaultPowerSaveDelay;

   200     aSettings.regionExpirationTime = KWlanDefaultRegionExpirationTime;

   201     aSettings.rrmMinMeasurementInterval = KWlanDefaultRrmMinMeasurementInterval;

   202     aSettings.psmServerMode = KWlanDefaultPsmServerMode;

   203     aSettings.bgScanPeakPeriodStart = KWlanDefaultBgScanPeakPeriodStart;

   204     aSettings.bgScanPeakPeriodEnd = KWlanDefaultBgScanPeakPeriodEnd;

   205     aSettings.bgScanIntervalPeak = KWlanDefaultBgScanIntervalPeakPeriod;

   206     aSettings.bgScanIntervalOffPeak = KWlanDefaultBgScanIntervalOffPeakPeriod;

   207     aSettings.automaticTrafficStreamMgmt = ETrue;   

   208     aSettings.region = KWlanDefaultRegion;                

   209     aSettings.regionTimestamp = KWlanDefaultRegionTimestamp;

   210     }

   211 

   212 // ---------------------------------------------------------

   213 // CWlanDeviceSettings::ReadL

   214 // Read data from CommDB and copies it to the parameter.

   215 // ---------------------------------------------------------

   216 //

   217 EXPORT_C void CWlanDeviceSettings::ReadL( SWlanDeviceSettings& aSettings )

   218     {

   219     DEBUG( "CWlanDeviceSettings::ReadL()" );

   220 

   221     ReadL( EFalse, aSettings );

   222     if ( aSettings.useDefaultSettings )

   223         {

   224         ReadL( ETrue, aSettings );

   225         }

   226     }

   227 

   228 // ---------------------------------------------------------

   229 // CWlanDeviceSettings::ReadL

   230 // Read data from CommDB and copies it to the parameter.

   231 // ---------------------------------------------------------

   232 //

   233 EXPORT_C void CWlanDeviceSettings::ReadL(

   234     TBool aGetDefaultSettings,

   235     SWlanDeviceSettings& aSettings )

   236     {

   237     DEBUG1( "CWlanDeviceSettings::ReadL() - GetDefaultSettings == %u",

   238             aGetDefaultSettings );

   239             

   240     // Initialize to hard coded default values

   241     GetDefaultSettings( aSettings );

   242 

   243     // Read private settings from CenRep

   244     ReadPrivateData( aSettings );

   245 

   246     DEBUG( "CWlanDeviceSettings::ReadL() - private data read!" );

   247 

   248     // Start reading CommsDat

   249     // Both tables has to been found

   250     User::LeaveIfNull( iDefTable );

   251     User::LeaveIfNull( iUsrTable );

   252     

   253     CCommsDbTableView* table;

   254     if ( aGetDefaultSettings )

   255         {

   256         table = iDefTable;

   257         }

   258     else

   259         {

   260         table = iUsrTable;

   261         }

   262 

   263     // Read (and convert enumerated) data.

   264     // NOTE! backgroundScanInterval is

   265     // always read from user table because they are not part of

   266     // advanced settings.

   267     //

   268     iUsrTable->ReadUintL( KBgScanInterval, aSettings.backgroundScanInterval );

   269     table->ReadBoolL( KUseDefaultSettings, aSettings.useDefaultSettings );

   270     table->ReadUintL( KWlanLongRetry, aSettings.longRetry );

   271     table->ReadUintL( KWlanShortRetry, aSettings.shortRetry );

   272     table->ReadUintL( KWlanRTSThreshold, aSettings.rts );

   273     table->ReadUintL( KWlanTxPowerLevel, aSettings.txPowerLevel );

   274     table->ReadBoolL( KWlanAllowRadioMeasurements, aSettings.allowRadioMeasurements );

   275     table->ReadUintL( KWlanPowerMode, aSettings.powerMode );

   276     DEBUG( "CWlanDeviceSettings::ReadL() - done" );

   277 

   278 #ifdef _DEBUG

   279 //    LogSettings( aSettings );

   280 #endif // _DEBUG

   281     }

   282 

   283 // ---------------------------------------------------------

   284 // CWlanDeviceSettings::WriteL

   285 // Save data to CommDB.

   286 // ---------------------------------------------------------

   287 //

   288 EXPORT_C void CWlanDeviceSettings::WriteL(

   289     const SWlanDeviceSettings& aSettings)

   290     {

   291     DEBUG( "CWlanDeviceSettings::WriteL()" );

   292     

   293     // Write private settings to CenRep

   294     WritePrivateData( aSettings );

   295     

   296     // Write CommsDat settings

   297     User::LeaveIfNull( iUsrTable );

   298     User::LeaveIfError( iUsrTable->UpdateRecord() ); // Begin changes.

   299 

   300     iUsrTable->WriteUintL( KBgScanInterval, aSettings.backgroundScanInterval );

   301     iUsrTable->WriteBoolL( KUseDefaultSettings, aSettings.useDefaultSettings );

   302     iUsrTable->WriteUintL( KWlanLongRetry, aSettings.longRetry );

   303     iUsrTable->WriteUintL( KWlanShortRetry, aSettings.shortRetry );

   304     iUsrTable->WriteUintL( KWlanRTSThreshold, aSettings.rts );

   305     iUsrTable->WriteUintL( KWlanTxPowerLevel, aSettings.txPowerLevel );

   306     iUsrTable->WriteBoolL( KWlanAllowRadioMeasurements, aSettings.allowRadioMeasurements );

   307     iUsrTable->WriteUintL( KWlanPowerMode, aSettings.powerMode );

   308 

   309     TInt err = iUsrTable->PutRecordChanges(); // End and save changes.

   310     

   311     if( err == KErrLocked )

   312         {

   313         for( TInt retryCount = 1; retryCount <= KMaxCommsDbWriteAttempts; retryCount++ )

   314             {

   315             DEBUG2( "CWlanDeviceSettings::WriteL() - CommsDb locked, waiting for %u us before retrying, retryCount: %u",

   316                     KRetryIntervalUsIfCommsDbLocked,

   317                     retryCount );

   318             User::After( TTimeIntervalMicroSeconds32( KRetryIntervalUsIfCommsDbLocked ) );

   319             err = iUsrTable->PutRecordChanges();

   320             if( err != KErrLocked )

   321                 {

   322                 break;

   323                 }

   324             }

   325         }

   326     

   327     User::LeaveIfError( err );

   328 

   329     DEBUG( "CWlanDeviceSettings::WriteL() - done" );

   330     }

   331 

   332 // ---------------------------------------------------------

   333 // CWlanDeviceSettings::ReadPrivateData

   334 // ---------------------------------------------------------

   335 //

   336 TInt CWlanDeviceSettings::ReadPrivateData( SWlanDeviceSettings& aSettings )

   337     {

   338     DEBUG( "CWlanDeviceSettings::ReadPrivateData()" );

   339     

   340     TInt err = KErrNone;

   341     CRepository* repository = NULL;

   342     TRAP( err, repository = CRepository::NewL( KCRUidWlanDeviceSettingsRegistryId ) );

   343     if( err != KErrNone )

   344         {

   345         DEBUG1( "CWlanDeviceSettings::ReadPrivateData() - Could not access repository (%d), using hardcoded values", err );

   346         return err;

   347         }

   348     // No need to use CleanupStack because no possibility to leave

   349 

   350     // Read KWlanBeacon

   351     TInt temp = 0;

   352     err = repository->Get( KWlanBeacon, temp );

   353     if( err == KErrNone ) 

   354         {

   355         aSettings.beacon = temp;

   356         }

   357 

   358     // Read KWlanScanRate

   359     err = repository->Get( KWlanScanRate, temp );

   360     if( err == KErrNone ) 

   361         {

   362         aSettings.scanRate = static_cast<TRate>( temp );

   363         }

   364 

   365     // Read KWlanRcpiTrigger

   366     err = repository->Get( KWlanRcpiTrigger, temp );

   367     if( err == KErrNone )

   368         {

   369         aSettings.rcpiTrigger = temp;

   370         }

   371 

   372     // Read KWlanMinActiveChannelTime

   373     err = repository->Get( KWlanMinActiveChannelTime, temp );

   374     if( err == KErrNone )

   375         {

   376         aSettings.minActiveChannelTime = temp;

   377         }

   378     

   379     // Read KWlanMaxActiveChannelTime

   380     err = repository->Get( KWlanMaxActiveChannelTime, temp );

   381     if( err == KErrNone )

   382         {

   383         aSettings.maxActiveChannelTime = temp;

   384         }

   385     

   386     // Read KWlanMaxTxMSDULifeTime

   387     err = repository->Get( KWlanMaxTxMSDULifeTime, temp );

   388     if( err == KErrNone )

   389         {

   390         aSettings.maxTxMSDULifeTime = temp;

   391         }

   392     

   393     // Read KWlanScanExpirationTimer

   394     err = repository->Get( KWlanScanExpirationTimer, temp );

   395     if( err == KErrNone )

   396         {

   397         aSettings.scanExpirationTimer = temp;

   398         }

   399     

   400     // Read KWlanUnloadDriverTimer

   401     err = repository->Get( KWlanUnloadDriverTimer, temp );

   402     if( err == KErrNone )

   403         {

   404         aSettings.unloadDriverTimer = temp;

   405         }

   406 

   407     // Read KWlanRoamTimer

   408     err = repository->Get( KWlanRoamTimer, temp );

   409     if( err == KErrNone )

   410         {

   411         aSettings.roamTimer = temp;

   412         }

   413         

   414     // Read KWlanRcpiDifference

   415     err = repository->Get( KWlanRcpiDifference, temp );

   416     if( err == KErrNone ) 

   417         {

   418         aSettings.rcpiDifference = temp;

   419         }

   420 

   421     // Read KWlanConnRegainTimer

   422     err = repository->Get( KWlanConnRegainTimer, temp );

   423     if( err == KErrNone ) 

   424         {

   425         aSettings.connRegainTimer = temp;

   426         }

   427 

   428     // Read KWlanMaxTriesToFindNw

   429     err = repository->Get( KWlanMaxTriesToFindNw, temp );

   430     if( err == KErrNone ) 

   431         {

   432         aSettings.maxTriesToFindNw = temp;

   433         }

   434 

   435     // Read KWlanDelayBetweenFindNw

   436     err = repository->Get( KWlanDelayBetweenFindNw, temp );

   437     if( err == KErrNone ) 

   438         {

   439         aSettings.delayBetweenFindNw = temp;

   440         }

   441 

   442     // Read KWlanMinPassiveChannelTime

   443     err = repository->Get( KWlanMinPassiveChannelTime, temp );

   444     if( err == KErrNone ) 

   445         {

   446         aSettings.minPassiveChannelTime = temp;

   447         }

   448 

   449     // Read KWlanMaxPassiveChannelTime

   450     err = repository->Get( KWlanMaxPassiveChannelTime, temp );

   451     if( err == KErrNone ) 

   452         {

   453         aSettings.maxPassiveChannelTime = temp;

   454         }

   455         

   456     // Read KWlanMaxApFailureCount

   457     err = repository->Get( KWlanMaxApFailureCount, temp );

   458     if( err == KErrNone ) 

   459         {

   460         aSettings.maxApFailureCount = temp;

   461         }

   462         

   463     // Read KWlanLongBeaconFindCount

   464     err = repository->Get( KWlanLongBeaconFindCount, temp );

   465     if( err == KErrNone ) 

   466         {

   467         aSettings.longBeaconFindCount = temp;

   468         }

   469         

   470     // Read KWlanQosNullFrameInterval

   471     err = repository->Get( KWlanQosNullFrameInterval, temp );

   472     if( err == KErrNone ) 

   473         {

   474         aSettings.qosNullFrameInterval = temp;

   475         }

   476         

   477     // Read KWlanQosNullFrameTimeout

   478     err = repository->Get( KWlanQosNullFrameTimeout, temp );

   479     if( err == KErrNone ) 

   480         {

   481         aSettings.qosNullFrameTimeout = temp;

   482         }                                

   483 

   484     // Read KWlanKeepAliveInterval

   485     err = repository->Get( KWlanKeepAliveInterval, temp );

   486     if( err == KErrNone ) 

   487         {

   488         aSettings.keepAliveInterval = temp;

   489         }                                

   490 

   491     // Read KWlanScanStopRcpiThreshold

   492     err = repository->Get( KWlanScanStopRcpiThreshold, temp );

   493     if( err == KErrNone ) 

   494         {

   495         aSettings.scanStopRcpiThreshold = temp;

   496         }                                

   497 

   498     // Read KWlanMinRcpiForIapAvailability

   499     err = repository->Get( KWlanMinRcpiForIapAvailability, temp );

   500     if( err == KErrNone ) 

   501         {

   502         aSettings.minRcpiForIapAvailability = temp;

   503         }                                

   504 

   505     // Read KWlanQoSNullFrameEntryTimeout

   506     err = repository->Get( KWlanQoSNullFrameEntryTimeout, temp );

   507     if( err == KErrNone ) 

   508         {

   509         aSettings.qosNullFrameEntryTimeout = temp;

   510         }                                

   511 

   512     // Read KWlanMaxApDeauthenticationCount

   513     err = repository->Get( KWlanMaxApDeauthenticationCount, temp );

   514     if( err == KErrNone ) 

   515         {

   516         aSettings.maxApDeauthenticationCount = temp;

   517         }                                

   518 

   519     // Read KWlanApDeauthenticationTimeout

   520     err = repository->Get( KWlanApDeauthenticationTimeout, temp );

   521     if( err == KErrNone ) 

   522         {

   523         aSettings.apDeauthenticationTimeout = temp;

   524         }                                

   525 

   526     // Read KWlanShowBrokenPowerSaveNote

   527     err = repository->Get( KWlanShowBrokenPowerSaveNote, temp );

   528     if( err == KErrNone ) 

   529         {

   530         aSettings.showBrokenPowerSaveNote = static_cast<TBool>( temp );

   531         }  

   532 

   533     // Read KWlanMaxDtimSkipInterval

   534     err = repository->Get( KWlanMaxDtimSkipInterval, temp );

   535     if( err == KErrNone ) 

   536         {

   537         aSettings.maxDtimSkipInterval = temp;

   538         }                                

   539     

   540     // Read KWlanPsActiveToLightTimeout

   541     err = repository->Get( KWlanPsActiveToLightTimeout, temp );

   542     if( err == KErrNone ) 

   543         {

   544         aSettings.psActiveToLightTimeout = temp;

   545         }       

   546 

   547     // Read KWlanPsActiveToLightThreshold

   548     err = repository->Get( KWlanPsActiveToLightThreshold, temp );

   549     if( err == KErrNone ) 

   550         {

   551         aSettings.psActiveToLightThreshold = temp;

   552         }       

   553 

   554     // Read KWlanPsLightToActiveTimeout

   555     err = repository->Get( KWlanPsLightToActiveTimeout, temp );

   556     if( err == KErrNone ) 

   557         {

   558         aSettings.psLightToActiveTimeout = temp;

   559         }       

   560 

   561     // Read KWlanPsLightToActiveThreshold

   562     err = repository->Get( KWlanPsLightToActiveThreshold, temp );

   563     if( err == KErrNone ) 

   564         {

   565         aSettings.psLightToActiveThreshold = temp;

   566         }       

   567 

   568     // Read KWlanPsLightToDeepTimeout

   569     err = repository->Get( KWlanPsLightToDeepTimeout, temp );

   570     if( err == KErrNone ) 

   571         {

   572         aSettings.psLightToDeepTimeout = temp;

   573         }       

   574 

   575     // Read KWlanPsLightToDeepThreshold

   576     err = repository->Get( KWlanPsLightToDeepThreshold, temp );

   577     if( err == KErrNone ) 

   578         {

   579         aSettings.psLightToDeepThreshold = temp;

   580         }       

   581 

   582     // Read KWlanPsUapsdRxFrameLengthThreshold

   583     err = repository->Get( KWlanPsUapsdRxFrameLengthThreshold, temp );

   584     if( err == KErrNone ) 

   585         {

   586         aSettings.psUapsdRxThreshold = temp;

   587         }       

   588 

   589     // Read KWlanRcpiRoamMinInterval

   590     err = repository->Get( KWlanRcpiRoamMinInterval, temp );

   591     if( err == KErrNone ) 

   592         {

   593         aSettings.rcpiRoamMinInterval = temp;

   594         }       

   595     

   596     // Read KWlanRcpiRoamMaxInterval

   597     err = repository->Get( KWlanRcpiRoamMaxInterval, temp );

   598     if( err == KErrNone ) 

   599         {

   600         aSettings.rcpiRoamMaxInterval = temp;

   601         }       

   602     

   603     // Read KWlanRcpiRoamAttemptsPerInterval

   604     err = repository->Get( KWlanRcpiRoamAttemptsPerInterval, temp );

   605     if( err == KErrNone ) 

   606         {

   607         aSettings.rcpiRoamAttemptsPerInterval = temp;

   608         }       

   609     

   610     // Read KWlanRcpiRoamNextIntervalFactor

   611     err = repository->Get( KWlanRcpiRoamNextIntervalFactor, temp );

   612     if( err == KErrNone ) 

   613         {

   614         aSettings.rcpiRoamNextIntervalFactor = temp;

   615         }       

   616     

   617     // Read KWlanRcpiRoamNextIntervalAddition

   618     err = repository->Get( KWlanRcpiRoamNextIntervalAddition, temp );

   619     if( err == KErrNone ) 

   620         {

   621         aSettings.rcpiRoamNextIntervalAddition = temp;

   622         }       

   623     

   624     // Read KWlanScanListExpirationTime

   625     err = repository->Get( KWlanScanListExpirationTime, temp );

   626     if( err == KErrNone ) 

   627         {

   628         aSettings.scanListExpirationTime = temp;

   629         }       

   630     

   631     // Read KWlanQoSNullFrameEntryTxCount

   632     err = repository->Get( KWlanQoSNullFrameEntryTxCount, temp );

   633     if( err == KErrNone ) 

   634         {

   635         aSettings.qosNullFrameEntryTxCount = temp;

   636         }       

   637     

   638     // Read KWlanSpRcpiTarget

   639     err = repository->Get( KWlanSpRcpiTarget, temp );

   640     if( err == KErrNone ) 

   641         {

   642         aSettings.spRcpiTarget = temp;

   643         }       

   644 

   645     // Read KWlanSpTimeTarget

   646     err = repository->Get( KWlanSpTimeTarget, temp );

   647     if( err == KErrNone ) 

   648         {

   649         aSettings.spTimeTarget = temp;

   650         }       

   651     

   652     // Read KWlanSpMinIndicationInterval

   653     err = repository->Get( KWlanSpMinIndicationInterval, temp );

   654     if( err == KErrNone ) 

   655         {

   656         aSettings.spMinIndicationInterval = temp;

   657         }       

   658     

   659     // Read KWlanBssLostRoamMinInterval

   660     err = repository->Get( KWlanBssLostRoamMinInterval, temp );

   661     if( err == KErrNone ) 

   662         {

   663         aSettings.bssLostRoamMinInterval = temp;

   664         }       

   665 

   666     // Read KWlanBssLostRoamMaxInterval

   667     err = repository->Get( KWlanBssLostRoamMaxInterval, temp );

   668     if( err == KErrNone ) 

   669         {

   670         aSettings.bssLostRoamMaxInterval = temp;

   671         }       

   672     

   673     // Read KWlanBssLostRoamAttemptsPerInterval

   674     err = repository->Get( KWlanBssLostRoamAttemptsPerInterval, temp );

   675     if( err == KErrNone ) 

   676         {

   677         aSettings.bssLostRoamAttemptsPerInterval = temp;

   678         }       

   679 

   680     // Read KWlanBssLostRoamNextIntervalFactor

   681     err = repository->Get( KWlanBssLostRoamNextIntervalFactor, temp );

   682     if( err == KErrNone ) 

   683         {

   684         aSettings.bssLostRoamNextIntervalFactor = temp;

   685         }       

   686     

   687     // Read KWlanBssLostRoamNextIntervalAddition

   688     err = repository->Get( KWlanBssLostRoamNextIntervalAddition, temp );

   689     if( err == KErrNone ) 

   690         {

   691         aSettings.bssLostRoamNextIntervalAddition = temp;

   692         }       

   693     

   694     // Read KWlanBssLostRoamMaxTriesToFindNw

   695     err = repository->Get( KWlanBssLostRoamMaxTriesToFindNw, temp );

   696     if( err == KErrNone ) 

   697         {

   698         aSettings.bssLostRoamMaxTriesToFindNw = temp;

   699         }       

   700     

   701     // Read KWlanTrafficStreamCreationTimeout

   702     err = repository->Get( KWlanTrafficStreamCreationTimeout, temp );

   703     if( err == KErrNone ) 

   704         {

   705         aSettings.trafficStreamCreationTimeout = temp;

   706         }       

   707     

   708     // Read KWlanBeaconLostThreshold

   709     err = repository->Get( KWlanBeaconLostThreshold, temp );

   710     if( err == KErrNone ) 

   711         {

   712         aSettings.beaconLostThreshold = temp;

   713         }       

   714     

   715     // Read KWlanBtBeaconLostThreshold

   716     err = repository->Get( KWlanBtBeaconLostThreshold, temp );

   717     if( err == KErrNone ) 

   718         {

   719         aSettings.btBeaconLostThreshold = temp;

   720         }       

   721 

   722     // Read KWlanTxFailThreshold

   723     err = repository->Get( KWlanTxFailThreshold, temp );

   724     if( err == KErrNone ) 

   725         {

   726         aSettings.txFailThreshold = temp;

   727         }       

   728 

   729     // Read KWlanBtTxFailThreshold

   730     err = repository->Get( KWlanBtTxFailThreshold, temp );

   731     if( err == KErrNone ) 

   732         {

   733         aSettings.btTxFailThreshold = temp;

   734         }       

   735 

   736     // Read KWlanPowerSaveDelay

   737     err = repository->Get( KWlanPowerSaveDelay, temp );

   738     if( err == KErrNone ) 

   739         {

   740         aSettings.powerSaveDelay = temp;

   741         }

   742 

   743     // Read KWlanRegionExpirationTime

   744     err = repository->Get( KWlanRegionExpirationTime, temp );

   745     if( err == KErrNone ) 

   746         {

   747         aSettings.regionExpirationTime = temp;

   748         }

   749 

   750     // Read KWlanRrmMinMeasurementInterval

   751     err = repository->Get( KWlanRrmMinMeasurementInterval, temp );

   752     if( err == KErrNone ) 

   753         {

   754         aSettings.rrmMinMeasurementInterval = temp;

   755         }  

   756 

   757     // Read KWlanPsmSrvMode

   758     err = repository->Get( KWlanPsmSrvMode, temp );

   759     if( err == KErrNone ) 

   760         {

   761         aSettings.psmServerMode = temp;

   762         }

   763     

   764     // Read KWlanBgScanPeakPeriodStart

   765     err = repository->Get( KWlanBgScanPeakPeriodStart, temp );

   766     if( err == KErrNone ) 

   767         {

   768         aSettings.bgScanPeakPeriodStart = temp;

   769         }

   770     

   771     // Read KWlanBgScanPeakPeriodEnd

   772     err = repository->Get( KWlanBgScanPeakPeriodEnd, temp );

   773     if( err == KErrNone ) 

   774         {

   775         aSettings.bgScanPeakPeriodEnd = temp;

   776         }

   777     

   778     // Read KWlanBgScanIntervalPeakPeriod

   779     err = repository->Get( KWlanBgScanIntervalPeakPeriod, temp );

   780     if( err == KErrNone ) 

   781         {

   782         aSettings.bgScanIntervalPeak = temp;

   783         }

   784 

   785     // Read KWlanBgScanIntervalOffPeakPeriod

   786     err = repository->Get( KWlanBgScanIntervalOffPeakPeriod, temp );

   787     if( err == KErrNone ) 

   788         {

   789         aSettings.bgScanIntervalOffPeak = temp;

   790         }

   791 		

   792     // Read KWlanAutomaticTrafficStreamMgmt

   793     err = repository->Get( KWlanAutomaticTrafficStreamMgmt, temp );

   794     if( err == KErrNone ) 

   795         {

   796         aSettings.automaticTrafficStreamMgmt = static_cast<TBool>( temp );

   797         }  

   798 

   799     // Read KWlanRegion

   800     err = repository->Get( KWlanRegion, temp );

   801     if( err == KErrNone ) 

   802         {

   803         aSettings.region = temp;

   804         }                                

   805 

   806     // Read KWlanRegionTimestamp

   807     err = repository->Get( KWlanRegionTimestamp, temp );

   808     if( err == KErrNone ) 

   809         {

   810         aSettings.regionTimestamp = temp;

   811         } 

   812 

   813     // Cleanup

   814     delete repository;

   815     DEBUG( "CWlanDeviceSettings::ReadPrivateData() - done" );

   816     return KErrNone;

   817     }

   818 

   819 // ---------------------------------------------------------

   820 // CWlanDeviceSettings::WriteCenRepKeyL

   821 // ---------------------------------------------------------

   822 //

   823 EXPORT_C void CWlanDeviceSettings::WriteCenRepKeyL( const TUint32 aKey, const TInt aValue ) const

   824     {

   825     DEBUG2( "CWlanDeviceSettings::WriteCenRepKeyL( aKey: 0x%X, aValue: %d )", aKey, aValue );

   826     

   827     CRepository* repository = CRepository::NewL( KCRUidWlanDeviceSettingsRegistryId );

   828 

   829     TInt err = repository->Set( aKey, aValue );

   830     if( err != KErrNone ) 

   831         {

   832         DEBUG2( "CWlanDeviceSettings::WriteCenRepKeyL() - Could not set value %d to key 0x%X", aValue, aKey );

   833         }

   834 

   835     // Cleanup

   836     delete repository;

   837     

   838     User::LeaveIfError( err );

   839     }

   840 

   841 // ---------------------------------------------------------

   842 // CWlanDeviceSettings::WritePrivateData

   843 // ---------------------------------------------------------

   844 //

   845 TInt CWlanDeviceSettings::WritePrivateData( const SWlanDeviceSettings& aSettings )

   846     {

   847     DEBUG( "CWlanDeviceSettings::WritePrivateData()" );

   848     

   849     TInt err = KErrNone;

   850     CRepository* repository = NULL;

   851     TRAP( err, repository = CRepository::NewL( KCRUidWlanDeviceSettingsRegistryId ) );

   852     if( err != KErrNone )

   853         {

   854         DEBUG1( "CWlanDeviceSettings::WritePrivateData() - Could not access repository (%d), not saving", err );

   855         return err;

   856         }

   857     // No need to use CleanupStack because no possibility to leave

   858     

   859     // Write KWlanBeacon

   860     err = repository->Set(

   861         KWlanBeacon, 

   862         static_cast<TInt>( aSettings.beacon ) );

   863     if( err ) 

   864         {

   865         DEBUG1( "CWlanDeviceSettings::WritePrivateData() - could not set key 0x%X", KWlanBeacon );

   866         }

   867 

   868     // Write KWlanScanRate

   869     err = repository->Set( 

   870         KWlanScanRate, 

   871         static_cast<TInt>( aSettings.scanRate ) );

   872     if( err ) 

   873         { 

   874         DEBUG1( "CWlanDeviceSettings::WritePrivateData() - could not set key 0x%X", KWlanScanRate ); 

   875         }

   876 

   877     // Write KWlanRcpiTrigger

   878     err = repository->Set( 

   879         KWlanRcpiTrigger, 

   880         static_cast<TInt>( aSettings.rcpiTrigger ) );

   881     if( err ) 

   882         {

   883         DEBUG1( "CWlanDeviceSettings::WritePrivateData() - could not set key 0x%X", KWlanRcpiTrigger );

   884     	}

   885 

   886     // Write KWlanMinActiveChannelTime

   887     err = repository->Set( 

   888         KWlanMinActiveChannelTime, 

   889         static_cast<TInt>( aSettings.minActiveChannelTime ) );

   890     if( err ) 

   891         {

   892         DEBUG1( "CWlanDeviceSettings::WritePrivateData() - could not set key 0x%X", KWlanMinActiveChannelTime );

   893         }

   894 

   895     // Write KWlanMaxActiveChannelTime

   896     err = repository->Set( 

   897         KWlanMaxActiveChannelTime, 

   898         static_cast<TInt>( aSettings.maxActiveChannelTime ) );

   899     if( err ) 

   900         { 

   901         DEBUG1( "CWlanDeviceSettings::WritePrivateData() - could not set key 0x%X", KWlanMaxActiveChannelTime );

   902         }

   903 

   904     // Write KWlanMaxTxMSDULifeTime

   905     err = repository->Set( 

   906         KWlanMaxTxMSDULifeTime, 

   907         static_cast<TInt>( aSettings.maxTxMSDULifeTime ) );

   908     if( err ) 

   909         {

   910         DEBUG1( "CWlanDeviceSettings::WritePrivateData() - could not set key 0x%X", KWlanMaxTxMSDULifeTime );

   911         }

   912 

   913     // Write KWlanScanExpirationTimer

   914     err = repository->Set( 

   915         KWlanScanExpirationTimer, 

   916         static_cast<TInt>( aSettings.scanExpirationTimer ) );

   917     if( err ) 

   918         {

   919         DEBUG1( "CWlanDeviceSettings::WritePrivateData() - could not set key 0x%X", KWlanScanExpirationTimer );

   920         }

   921 

   922     // Write KWlanUnloadDriverTimer

   923     err = repository->Set( 

   924         KWlanUnloadDriverTimer, 

   925         static_cast<TInt>( aSettings.unloadDriverTimer ) );

   926     if( err ) 

   927         {

   928         DEBUG1( "CWlanDeviceSettings::WritePrivateData() - could not set key 0x%X", KWlanUnloadDriverTimer );

   929         }

   930 

   931     // Write KWlanRoamTimer

   932     err = repository->Set( 

   933         KWlanRoamTimer, 

   934         static_cast<TInt>( aSettings.roamTimer ) );

   935     if( err ) 

   936         {

   937         DEBUG1( "CWlanDeviceSettings::WritePrivateData() - could not set key 0x%X", KWlanRoamTimer );

   938         }

   939 

   940     // Write KWlanRcpiDifference

   941     err = repository->Set( 

   942         KWlanRcpiDifference, 

   943         static_cast<TInt>( aSettings.rcpiDifference ) );

   944     if( err ) 

   945         { 

   946         DEBUG1( "CWlanDeviceSettings::WritePrivateData() - could not set key 0x%X", KWlanRcpiDifference );

   947         }

   948 

   949     // Write KWlanConnRegainTimer

   950     err = repository->Set( 

   951         KWlanConnRegainTimer, 

   952         static_cast<TInt>( aSettings.connRegainTimer ) );

   953     if( err ) 

   954         {

   955         DEBUG1( "CWlanDeviceSettings::WritePrivateData() - could not set key 0x%X", KWlanConnRegainTimer );

   956         }

   957 

   958     // Write KWlanMaxTriesToFindNw

   959     err = repository->Set( 

   960         KWlanMaxTriesToFindNw, 

   961         static_cast<TInt>( aSettings.maxTriesToFindNw ) );

   962     if( err ) 

   963         {

   964         DEBUG1( "CWlanDeviceSettings::WritePrivateData() - could not set key 0x%X", KWlanMaxTriesToFindNw );

   965         }

   966 

   967     // Write KWlanDelayBetweenFindNw

   968     err = repository->Set( 

   969         KWlanDelayBetweenFindNw, 

   970         static_cast<TInt>( aSettings.delayBetweenFindNw ) );

   971     if( err ) 

   972         {

   973         DEBUG1( "CWlanDeviceSettings::WritePrivateData() - could not set key 0x%X", KWlanDelayBetweenFindNw );

   974         }

   975 

   976     // Write KWlanMinPassiveChannelTime

   977     err = repository->Set( 

   978         KWlanMinPassiveChannelTime, 

   979         static_cast<TInt>( aSettings.minPassiveChannelTime ) );

   980     if( err ) 

   981         {

   982         DEBUG1( "CWlanDeviceSettings::WritePrivateData() - could not set key 0x%X", KWlanMinPassiveChannelTime );

   983         }

   984 

   985     // Write KWlanMaxPassiveChannelTime

   986     err = repository->Set( 

   987         KWlanMaxPassiveChannelTime, 

   988         static_cast<TInt>( aSettings.maxPassiveChannelTime ) );

   989     if( err ) 

   990         {

   991         DEBUG1( "CWlanDeviceSettings::WritePrivateData() - could not set key 0x%X", KWlanMaxPassiveChannelTime );

   992         }

   993 

   994     // Write KWlanMaxApFailureCount

   995     err = repository->Set( 

   996         KWlanMaxApFailureCount, 

   997         static_cast<TInt>( aSettings.maxApFailureCount ) );

   998     if( err ) 

   999         {

  1000         DEBUG1( "CWlanDeviceSettings::WritePrivateData() - could not set key 0x%X", KWlanMaxApFailureCount );

  1001         }

  1002 

  1003     // Write KWlanLongBeaconFindCount

  1004     err = repository->Set( 

  1005         KWlanLongBeaconFindCount, 

  1006         static_cast<TInt>( aSettings.longBeaconFindCount ) );

  1007     if( err ) 

  1008         {

  1009         DEBUG1( "CWlanDeviceSettings::WritePrivateData() - could not set key 0x%X", KWlanLongBeaconFindCount );

  1010         }

  1011 

  1012     // Write KWlanQosNullFrameInterval

  1013     err = repository->Set( 

  1014         KWlanQosNullFrameInterval, 

  1015         static_cast<TInt>( aSettings.qosNullFrameInterval ) );

  1016     if( err ) 

  1017         {

  1018         DEBUG1( "CWlanDeviceSettings::WritePrivateData() - could not set key 0x%X", KWlanQosNullFrameInterval );

  1019         }

  1020 

  1021     // Write KWlanQosNullFrameTimeout

  1022     err = repository->Set( 

  1023         KWlanQosNullFrameTimeout, 

  1024         static_cast<TInt>( aSettings.qosNullFrameTimeout ) );

  1025     if( err ) 

  1026         {

  1027         DEBUG1( "CWlanDeviceSettings::WritePrivateData() - could not set key 0x%X", KWlanQosNullFrameTimeout );

  1028         }

  1029 

  1030     // Write KWlanKeepAliveInterval

  1031     err = repository->Set( 

  1032     	KWlanKeepAliveInterval, 

  1033         static_cast<TInt>( aSettings.keepAliveInterval ) );

  1034     if( err ) 

  1035         {

  1036         DEBUG1( "CWlanDeviceSettings::WritePrivateData() - could not set key 0x%X", KWlanKeepAliveInterval );

  1037         }

  1038 

  1039     // Write KWlanScanStopRcpiThreshold

  1040     err = repository->Set( 

  1041     	KWlanScanStopRcpiThreshold, 

  1042         static_cast<TInt>( aSettings.scanStopRcpiThreshold ) );

  1043     if( err ) 

  1044         {

  1045         DEBUG1( "CWlanDeviceSettings::WritePrivateData() - could not set key 0x%X", KWlanScanStopRcpiThreshold );

  1046         }

  1047 

  1048     // Write KWlanMinRcpiForIapAvailability

  1049     err = repository->Set( 

  1050     	KWlanMinRcpiForIapAvailability, 

  1051         static_cast<TInt>( aSettings.minRcpiForIapAvailability ) );

  1052     if( err ) 

  1053         {

  1054         DEBUG1( "CWlanDeviceSettings::WritePrivateData() - could not set key 0x%X", KWlanMinRcpiForIapAvailability );

  1055         }

  1056 

  1057     // Write KWlanQoSNullFrameEntryTimeout

  1058     err = repository->Set( 

  1059     	KWlanQoSNullFrameEntryTimeout, 

  1060         static_cast<TInt>( aSettings.qosNullFrameEntryTimeout ) );

  1061     if( err ) 

  1062         {

  1063         DEBUG1( "CWlanDeviceSettings::WritePrivateData() - could not set key 0x%X", KWlanQoSNullFrameEntryTimeout );

  1064         }

  1065 

  1066     // Write KWlanMaxApDeauthenticationCount

  1067     err = repository->Set( 

  1068     	KWlanMaxApDeauthenticationCount, 

  1069         static_cast<TInt>( aSettings.maxApDeauthenticationCount ) );

  1070     if( err ) 

  1071         {

  1072         DEBUG1( "CWlanDeviceSettings::WritePrivateData() - could not set key 0x%X", KWlanMaxApDeauthenticationCount );

  1073         }

  1074 

  1075     // Write KWlanApDeauthenticationTimeout

  1076     err = repository->Set( 

  1077     	KWlanApDeauthenticationTimeout, 

  1078         static_cast<TInt>( aSettings.apDeauthenticationTimeout ) );

  1079     if( err ) 

  1080         {

  1081         DEBUG1( "CWlanDeviceSettings::WritePrivateData() - could not set key 0x%X", KWlanApDeauthenticationTimeout );

  1082         }

  1083 

  1084     // Write KWlanShowBrokenPowerSaveNote

  1085     err = repository->Set( 

  1086         KWlanShowBrokenPowerSaveNote, 

  1087         static_cast<TInt>( aSettings.showBrokenPowerSaveNote ) );

  1088     if( err ) 

  1089         {

  1090         DEBUG1( "CWlanDeviceSettings::WritePrivateData() - could not set key 0x%X", KWlanShowBrokenPowerSaveNote );

  1091         }

  1092 

  1093     // Write KWlanMaxDtimSkipInterval

  1094     err = repository->Set( 

  1095         KWlanMaxDtimSkipInterval, 

  1096         static_cast<TInt>( aSettings.maxDtimSkipInterval ) );

  1097     if( err ) 

  1098         {

  1099         DEBUG1( "CWlanDeviceSettings::WritePrivateData() - could not set key 0x%X", KWlanMaxDtimSkipInterval );

  1100         }    

  1101 

  1102     // Write KWlanPsActiveToLightTimeout

  1103     err = repository->Set( 

  1104         KWlanPsActiveToLightTimeout, 

  1105         static_cast<TInt>( aSettings.psActiveToLightTimeout ) );

  1106     if( err ) 

  1107         {

  1108         DEBUG1( "CWlanDeviceSettings::WritePrivateData() - could not set key 0x%X", KWlanPsActiveToLightTimeout );

  1109         }   

  1110 

  1111     // Write KWlanPsActiveToLightThreshold

  1112     err = repository->Set( 

  1113         KWlanPsActiveToLightThreshold, 

  1114         static_cast<TInt>( aSettings.psActiveToLightThreshold ) );

  1115     if( err ) 

  1116         {

  1117         DEBUG1( "CWlanDeviceSettings::WritePrivateData() - could not set key 0x%X", KWlanPsActiveToLightThreshold );

  1118         }   

  1119 

  1120     // Write KWlanPsLightToActiveTimeout

  1121     err = repository->Set( 

  1122         KWlanPsLightToActiveTimeout, 

  1123         static_cast<TInt>( aSettings.psLightToActiveTimeout ) );

  1124     if( err ) 

  1125         {

  1126         DEBUG1( "CWlanDeviceSettings::WritePrivateData() - could not set key 0x%X", KWlanPsLightToActiveTimeout );

  1127         }   

  1128 

  1129     // Write KWlanPsLightToActiveThreshold

  1130     err = repository->Set( 

  1131         KWlanPsLightToActiveThreshold, 

  1132         static_cast<TInt>( aSettings.psLightToActiveThreshold ) );

  1133     if( err ) 

  1134         {