/*

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:  Interface to read and write WLAN device specific settings.

*

*/

/*

*/

// INCLUDE FILES

#include <commdb.h>

#include <centralrepository.h>

#include <commsdattypesv1_1.h>

#include <e32std.h>

#include "am_debug.h"

#include "wlandevicesettings.h"

#include "wlandevicesettingsprivatecrkeys.h"

// CONSTANTS

// Ids for Wlan settings type.

const TUint32 KWlanDefaultSettings            = 0;

const TUint32 KWlanUserSettings               = 1;

const TUint32 KMaxCommsDbWriteAttempts        = 10;

const TUint32 KRetryIntervalUsIfCommsDbLocked = 100000;

// Table name

_LIT( KWlanDeviceSettings,          "WLANDeviceTable" );

_LIT( KTableVersion,                "Version");

_LIT( KWlanDeviceSettingsType,      "WlanDeviceSettingsType" );

_LIT( KBgScanInterval,              "WlanBgScanInterval" );

_LIT( KUseDefaultSettings,          "WlanUseDefaultSettings" );

_LIT( KWlanLongRetry,               "WlanLongRetry" );

_LIT( KWlanRTSThreshold,            "WlanRTS" );

_LIT( KWlanShortRetry,              "WlanShortRetry" );

_LIT( KWlanTxPowerLevel,            "WlanTxPowerLevel" );

_LIT( KWlanAllowRadioMeasurements,  "AllowRadioMeasurements" );

_LIT( KWlanPowerMode,               "WlanPowerMode" );

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

const TUint32 KWlanDeviceSettingsTableVersion = 9;

// LOCAL FUNCTION PROTOTYPES

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

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

// ---------------------------------------------------------

// CWlanDeviceSettings::CWlanDeviceSettings

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

//       initialised with zero. The initialisation of its

//       attributes is unnecessary.

// ---------------------------------------------------------

//

CWlanDeviceSettings::CWlanDeviceSettings()

    {

    } 

// ---------------------------------------------------------

// CWlanDeviceSettings::ConstructL

// ---------------------------------------------------------

//

void CWlanDeviceSettings::ConstructL()

    {

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

    // Open the CommsDB.

    iDb = CCommsDatabase::NewL();

    // Check that the version of WlanDeviceSettings is correct.

    TRAPD( err, CheckWlanDeviceSettingsTableL() );

    if ( err != KErrNone )

        {

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

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

        delete iDb;

        iDb = NULL;

        User::Leave( err );

        }

    // Open the WLAN device settings table.

    OpenTableL();

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

    }

// ---------------------------------------------------------

// CWlanDeviceSettings::NewL

// ---------------------------------------------------------

//

EXPORT_C CWlanDeviceSettings* CWlanDeviceSettings::NewL()

    {

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

    CWlanDeviceSettings* self = new (ELeave) CWlanDeviceSettings;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// ---------------------------------------------------------

// CWlanDeviceSettings::~CWlanDeviceSettings

// ---------------------------------------------------------

//

EXPORT_C CWlanDeviceSettings::~CWlanDeviceSettings()

    {

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

    delete iDefTable;

    delete iUsrTable;

    delete iDb;

    }

// ---------------------------------------------------------

// CWlanDeviceSettings::GetDefaultSettings

// ---------------------------------------------------------

//

EXPORT_C void CWlanDeviceSettings::GetDefaultSettings( 

    SWlanDeviceSettings& aSettings )

    {

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

    aSettings.beacon = KWlanDefaultBeacon;

    aSettings.longRetry = KWlanDefaultLongRetryLimit;

    aSettings.rts = KWlanDefaultRTSThreshold;

    aSettings.shortRetry = KWlanDefaultShortRetryLimit;

    aSettings.backgroundScanInterval = KWlanDefaultBackgroundScanInterval;

    aSettings.txPowerLevel = KWlanDefaultTxPowerLevel;

    aSettings.scanRate = E1Mbps;

    aSettings.rcpiTrigger = KWlanDefaultRcpiTrigger;

    aSettings.minActiveChannelTime = KWlanDefaultMinChanneltime;

    aSettings.maxActiveChannelTime = KWlanDefaultMaxChanneltime;

    aSettings.maxTxMSDULifeTime = KWlanDefaultMaxTransmitMSDULifetime;

    aSettings.useDefaultSettings = ETrue;		

    aSettings.scanExpirationTimer = KWlanDefaultScanExpirationTimer;

    aSettings.unloadDriverTimer = KWlanDefaultUnloadDriverTimer;

    aSettings.roamTimer = KWlanDefaultRoamTimer;

    aSettings.rcpiDifference = KWlanDefaultRcpiDifference;

    aSettings.connRegainTimer = KWlanDefaultConnRegainTimer;

    aSettings.maxTriesToFindNw = KWlanDefaultMaxTriesToFindNw;

    aSettings.delayBetweenFindNw = KWlanDefaultDelayBetweenFindNw;

    aSettings.powerMode = KWlanDefaultowerMode;

    aSettings.allowRadioMeasurements = ETrue;

    aSettings.minPassiveChannelTime = KWlanDefaultMinPassiveChannelTime;

    aSettings.maxPassiveChannelTime = KWlanDefaultMaxPassiveChannelTime;

    aSettings.maxApFailureCount = KWlanDefaultMaxApFailureCount;

    aSettings.maxApAuthFailureCount = KWlanDefaultMaxApAuthFailureCount;

    aSettings.longBeaconFindCount = KWlanDefaultLongBeaconFindCount;

    aSettings.qosNullFrameInterval = KWlanDefaultQosNullFrameInterval;

    aSettings.qosNullFrameTimeout = KWlanDefaultQosNullFrameTimeout;

    aSettings.keepAliveInterval = KWlanDefaultKeepAliveInterval;          

    aSettings.scanStopRcpiThreshold = KWlanDefaultScanStopRcpiThreshold;      

    aSettings.minRcpiForIapAvailability = KWlanDefaultMinRcpiForIapAvailability;  

    aSettings.qosNullFrameEntryTimeout = KWlanDefaultQoSNullFrameEntryTimeout;   

    aSettings.maxApDeauthenticationCount = KWlanDefaultMaxApDeauthenticationCount; 

    aSettings.apDeauthenticationTimeout = KWlanDefaultApDeauthenticationTimeout;  

    aSettings.maxDtimSkipInterval = KWlanDefaultMaxDtimSkipInterval;

    aSettings.psActiveToLightTimeout = KWlanDefaultPsActiveToLightTimeout;

    aSettings.psActiveToLightThreshold = KWlanDefaultPsActiveToLightThreshold;

    aSettings.psLightToActiveTimeout = KWlanDefaultPsLightToActiveTimeout;

    aSettings.psLightToActiveThreshold = KWlanDefaultPsLightToActiveThreshold;

    aSettings.psLightToDeepTimeout = KWlanDefaultPsLightToDeepTimeout;

    aSettings.psLightToDeepThreshold = KWlanDefaultPsLightToDeepThreshold;

    aSettings.psUapsdRxThreshold = KWlanDefaultPsUapsdRxFrameLengthThreshold;    

    aSettings.rcpiRoamMinInterval = KWlanDefaultRcpiRoamMinInterval;

    aSettings.rcpiRoamMaxInterval = KWlanDefaultRcpiRoamMaxInterval;

    aSettings.rcpiRoamAttemptsPerInterval = KWlanDefaultRcpiRoamAttemptsPerInterval;

    aSettings.rcpiRoamNextIntervalFactor = KWlanDefaultRcpiRoamNextIntervalFactor;

    aSettings.rcpiRoamNextIntervalAddition = KWlanDefaultRcpiRoamNextIntervalAddition;

    aSettings.scanListExpirationTime = KWlanDefaultScanListExpirationTime;

    aSettings.qosNullFrameEntryTxCount = KWlanDefaultQoSNullFrameEntryTxCount;

    aSettings.spRcpiTarget = KWlanDefaultSpRcpiTarget;

    aSettings.spTimeTarget = KWlanDefaultSpTimeTarget;

    aSettings.spMinIndicationInterval = KWlanDefaultSpMinIndicationInterval;

    aSettings.bssLostRoamMinInterval = KWlanDefaultBssLostRoamMinInterval;

    aSettings.bssLostRoamMaxInterval = KWlanDefaultBssLostRoamMaxInterval;

    aSettings.bssLostRoamAttemptsPerInterval = KWlanDefaultBssLostRoamAttemptsPerInterval;

    aSettings.bssLostRoamNextIntervalFactor = KWlanDefaultBssLostRoamNextIntervalFactor;

    aSettings.bssLostRoamNextIntervalAddition = KWlanDefaultBssLostRoamNextIntervalAddition;

    aSettings.bssLostRoamMaxTriesToFindNw = KWlanDefaultBssLostRoamMaxTriesToFindNw;

    aSettings.trafficStreamCreationTimeout = KWlanDefaultTrafficStreamCreationTimeout;

    aSettings.beaconLostThreshold = KWlanDefaultBeaconLostThreshold;

    aSettings.btBeaconLostThreshold = KWlanDefaultBtBeaconLostThreshold;

    aSettings.txFailThreshold = KWlanDefaultTxFailThreshold;

    aSettings.btTxFailThreshold = KWlanDefaultBtTxFailThreshold;

    aSettings.powerSaveDelay = KWlanDefaultPowerSaveDelay;

    aSettings.regionExpirationTime = KWlanDefaultRegionExpirationTime;

    aSettings.rrmMinMeasurementInterval = KWlanDefaultRrmMinMeasurementInterval;

    aSettings.psmServerMode = KWlanDefaultPsmServerMode;

    aSettings.bgScanPeakPeriodStart = KWlanDefaultBgScanPeakPeriodStart;

    aSettings.bgScanPeakPeriodEnd = KWlanDefaultBgScanPeakPeriodEnd;

    aSettings.bgScanIntervalPeak = KWlanDefaultBgScanIntervalPeakPeriod;

    aSettings.bgScanIntervalOffPeak = KWlanDefaultBgScanIntervalOffPeakPeriod;

    aSettings.automaticTrafficStreamMgmt = ETrue;   

    aSettings.region = KWlanDefaultRegion;                

    aSettings.regionTimestamp = KWlanDefaultRegionTimestamp;

    }

// ---------------------------------------------------------

// CWlanDeviceSettings::ReadL

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

// ---------------------------------------------------------

//

EXPORT_C void CWlanDeviceSettings::ReadL( SWlanDeviceSettings& aSettings )

    {

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

    ReadL( EFalse, aSettings );

    if ( aSettings.useDefaultSettings )

        {

        ReadL( ETrue, aSettings );

        }

    }

// ---------------------------------------------------------

// CWlanDeviceSettings::ReadL

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

// ---------------------------------------------------------

//

EXPORT_C void CWlanDeviceSettings::ReadL(

    TBool aGetDefaultSettings,

    SWlanDeviceSettings& aSettings )

    {

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

            aGetDefaultSettings );

    // Initialize to hard coded default values

    GetDefaultSettings( aSettings );

    // Read private settings from CenRep

    ReadPrivateData( aSettings );

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

    // Start reading CommsDat

    // Both tables has to been found

    User::LeaveIfNull( iDefTable );

    User::LeaveIfNull( iUsrTable );

    CCommsDbTableView* table;

    if ( aGetDefaultSettings )

        {

        table = iDefTable;

        }

    else

        {

        table = iUsrTable;

        }

    // Read (and convert enumerated) data.

    // NOTE! backgroundScanInterval is

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

    // advanced settings.

    //

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

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

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

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

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

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

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

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

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

#ifdef _DEBUG

//    LogSettings( aSettings );

#endif // _DEBUG

    }

// ---------------------------------------------------------

// CWlanDeviceSettings::WriteL

// Save data to CommDB.

// ---------------------------------------------------------

//

EXPORT_C void CWlanDeviceSettings::WriteL(

    const SWlanDeviceSettings& aSettings)

    {

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

    // Write private settings to CenRep

    WritePrivateData( aSettings );

    // Write CommsDat settings

    User::LeaveIfNull( iUsrTable );

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

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

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

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

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

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

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

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

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

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

    if( err == KErrLocked )

        {

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

            {

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

                    KRetryIntervalUsIfCommsDbLocked,

                    retryCount );

            User::After( TTimeIntervalMicroSeconds32( KRetryIntervalUsIfCommsDbLocked ) );

            err = iUsrTable->PutRecordChanges();

            if( err != KErrLocked )

                {

                break;

                }

            }

        }

    User::LeaveIfError( err );

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

    }

// ---------------------------------------------------------

// CWlanDeviceSettings::ReadPrivateData

// ---------------------------------------------------------

//

TInt CWlanDeviceSettings::ReadPrivateData( SWlanDeviceSettings& aSettings )

    {

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

    TInt err = KErrNone;

    CRepository* repository = NULL;

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

    if( err != KErrNone )

        {

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

        return err;

        }

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

    // Read KWlanBeacon

    TInt temp = 0;

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

    if( err == KErrNone ) 

        {

        aSettings.beacon = temp;

        }

    // Read KWlanScanRate

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

    if( err == KErrNone ) 

        {

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

        }

    // Read KWlanRcpiTrigger

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

    if( err == KErrNone )

        {

        aSettings.rcpiTrigger = temp;

        }

    // Read KWlanMinActiveChannelTime

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

    if( err == KErrNone )

        {

        aSettings.minActiveChannelTime = temp;

        }

    // Read KWlanMaxActiveChannelTime

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

    if( err == KErrNone )

        {

        aSettings.maxActiveChannelTime = temp;

        }

    // Read KWlanMaxTxMSDULifeTime

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

    if( err == KErrNone )

        {

        aSettings.maxTxMSDULifeTime = temp;

        }

    // Read KWlanScanExpirationTimer

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

    if( err == KErrNone )

        {

        aSettings.scanExpirationTimer = temp;

        }

    // Read KWlanUnloadDriverTimer

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

    if( err == KErrNone )

        {

        aSettings.unloadDriverTimer = temp;

        }

    // Read KWlanRoamTimer

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

    if( err == KErrNone )

        {

        aSettings.roamTimer = temp;

        }

    // Read KWlanRcpiDifference

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

    if( err == KErrNone ) 

        {

        aSettings.rcpiDifference = temp;

        }

    // Read KWlanConnRegainTimer

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

    if( err == KErrNone ) 

        {

        aSettings.connRegainTimer = temp;

        }

    // Read KWlanMaxTriesToFindNw

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

    if( err == KErrNone ) 

        {

        aSettings.maxTriesToFindNw = temp;

        }

    // Read KWlanDelayBetweenFindNw

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

    if( err == KErrNone ) 

        {

        aSettings.delayBetweenFindNw = temp;

        }

    // Read KWlanMinPassiveChannelTime

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

    if( err == KErrNone ) 

        {

        aSettings.minPassiveChannelTime = temp;

        }

    // Read KWlanMaxPassiveChannelTime

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

    if( err == KErrNone ) 

        {

        aSettings.maxPassiveChannelTime = temp;

        }

    // Read KWlanMaxApFailureCount

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

    if( err == KErrNone ) 

        {

        aSettings.maxApFailureCount = temp;

        }

    // Read KWlanLongBeaconFindCount

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

    if( err == KErrNone ) 

        {

        aSettings.longBeaconFindCount = temp;

        }

    // Read KWlanQosNullFrameInterval

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

    if( err == KErrNone ) 

        {

        aSettings.qosNullFrameInterval = temp;

        }

    // Read KWlanQosNullFrameTimeout

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

    if( err == KErrNone ) 

        {

        aSettings.qosNullFrameTimeout = temp;

        }                                

    // Read KWlanKeepAliveInterval

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

    if( err == KErrNone ) 

        {

        aSettings.keepAliveInterval = temp;

        }                                

    // Read KWlanScanStopRcpiThreshold

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

    if( err == KErrNone ) 

        {

        aSettings.scanStopRcpiThreshold = temp;

        }                                

    // Read KWlanMinRcpiForIapAvailability

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

    if( err == KErrNone ) 

        {

        aSettings.minRcpiForIapAvailability = temp;

        }                                

    // Read KWlanQoSNullFrameEntryTimeout

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

    if( err == KErrNone ) 

        {

        aSettings.qosNullFrameEntryTimeout = temp;

        }                                

    // Read KWlanMaxApDeauthenticationCount

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

    if( err == KErrNone ) 

        {

        aSettings.maxApDeauthenticationCount = temp;

        }                                

    // Read KWlanApDeauthenticationTimeout

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

    if( err == KErrNone ) 

        {

        aSettings.apDeauthenticationTimeout = temp;

        }                                

    // Read KWlanMaxDtimSkipInterval

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

    if( err == KErrNone ) 

        {