/*
* Copyright (c) 2002-2010 Nokia Corporation and/or its subsidiary(-ies).
* 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:   Implementation of WlanContextImpl inline methods.
*
*/

/*
* %version: 76 %
*/

#include "umacconnectcontext.h"

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline WlanMacState& WlanContextImpl::CurrentState()
    {
    return *iCurrentMacState;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline WHA::SSettings& WlanContextImpl::WHASettings()
    {
    return iWHASettings;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline const WHA::SSettings& WlanContextImpl::WHASettings() const
    {
    return iWHASettings;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::WHASettings( 
    const WHA::SSettings& aSSettings )
    {
    iWHASettings = aSSettings;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline SAuthenticationFrame& WlanContextImpl::GetAuthenticationFrame()
    {
    return iManagementFrameTemplates.iAuthenticationFrame;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline SHtAuthenticationFrame& WlanContextImpl::GetHtAuthenticationFrame()
    {
    return iManagementFrameTemplates.iHtAuthenticationFrame;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline SAssociationRequestFrame& 
WlanContextImpl::GetAssociationRequestFrame() 
    {
    return  iManagementFrameTemplates.iAssociationRequestFrame;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline SHtAssociationRequestFrame& 
WlanContextImpl::GetHtAssociationRequestFrame() 
    {
    return  iManagementFrameTemplates.iHtAssociationRequestFrame;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline SDeauthenticateFrame& WlanContextImpl::GetDeauthenticateFrame() 
    {
    return iManagementFrameTemplates.iDeauthenticateFrame;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline SHtDeauthenticateFrame& WlanContextImpl::GetHtDeauthenticateFrame() 
    {
    return iManagementFrameTemplates.iHtDeauthenticateFrame;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline SDisassociateFrame& WlanContextImpl::GetDisassociationFrame()
    {
    return iManagementFrameTemplates.iDisassociationFrame;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline SHtDisassociateFrame& WlanContextImpl::GetHtDisassociationFrame()
    {
    return iManagementFrameTemplates.iHtDisassociationFrame;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline SReassociationRequestFrame& WlanContextImpl::GetReassociationRequestFrame()
    {
    return iManagementFrameTemplates.iReassociationRequestFrame;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline SHtReassociationRequestFrame& 
WlanContextImpl::GetHtReassociationRequestFrame()
    {
    return iManagementFrameTemplates.iHtReassociationRequestFrame;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline SNullDataFrame& WlanContextImpl::NullDataFrame()
    {
    return iNullDataFrame;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline SHtQosNullDataFrame& WlanContextImpl::QosNullDataFrame()
    {
    return iQosNullDataFrame;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TUint16 WlanContextImpl::QosNullDataFrameLength() const
    {
    return ( HtSupportedByNw() ? 
                sizeof( SHtQosNullDataFrame ) :
                sizeof( SQosNullDataFrame ) );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline SDataFrameHeader& WlanContextImpl::GetDataFrameHeader() 
    {
    return iDataFrameHeader;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TWlanUserTxDataCntx& WlanContextImpl::GetTxDataCntx()
    {
    return iTxDataCntx;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline const TWlanUserTxDataCntx& WlanContextImpl::GetTxDataCntx() const
    {
    return iTxDataCntx;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TWlanUserTxDataCntx& WlanContextImpl::GetMgmtTxDataCntx()
    {
    return iMgmtTxDataCntx;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::ResetAuthSeqNmbrExpected()
    {
    iAuthSeqNmbrExpected.Reset();
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::TxRatePolicy(
    WHA::TQueueId aQueueId,
    TBool aUseSpecialRatePolicy,
    WHA::TRate& aRate, 
    TUint8& aPolicyId ) const
    {
    return iTxRateAdaptation.RatePolicy( 
        *this, 
        aQueueId, 
        aUseSpecialRatePolicy, 
        aRate, 
        aPolicyId );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TMacAddress& WlanContextImpl::GetBssId() 
    {
    return iConnectContext.iBSSID;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::Aid( const TUint32 aAid )
    {
    iConnectContext.iAid = aAid;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TUint32 WlanContextImpl::Aid() const
    {
    return iConnectContext.iAid;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::AtimWindow( const TUint32 aAtimWindow )
    {
    iConnectContext.iAtim = aAtimWindow;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TUint32 WlanContextImpl::AtimWindow() const
    {
    return iConnectContext.iAtim;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TSSID& WlanContextImpl::GetSsId()
    {
    return iConnectContext.iSSID;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TEncryptionStatus& WlanContextImpl::EncryptionStatus() 
    {
    return iConnectContext.iEncryptionStatus;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TUint16& WlanContextImpl::AuthenticationAlgorithmNumber()
    {
    return iConnectContext.iAuthAlgorithmNbr;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::OnTxCompleted( 
    const TUint32 aRate, 
    const TBool aSuccess,
    WHA::TQueueId aQueueId,
    WHA::TRate aRequestedRate )
    {
    if ( !( WHASettings().iCapability & 
         WHA::SSettings::KAutonomousRateAdapt ) )
        {
        // as autonomous rate adaptation is not being used, inform our own
        // rate adaptation object about Tx completion
        iTxRateAdaptation.OnTxCompleted( aRate, aSuccess, aQueueId, 
            aRequestedRate );        
        }
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::CancelTimer()
    {
    iUmac.CancelTimeout();
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TUint8 WlanContextImpl::GetAuthSeqNmbrExpected() const
    {
    return iAuthSeqNmbrExpected.GetAuthSeqNmbrExpected();
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline SSupportedRatesIE& WlanContextImpl::GetOurSupportedRatesIE()
    {
    return iConnectContext.iOurSupportedRates;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline SExtendedSupportedRatesIE& WlanContextImpl::GetOurExtendedSupportedRatesIE()
    {
    return iConnectContext.iOurExtendedSupportedRates;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::SetScanResponseFrameBody( const TUint8* aBody )
    {
    iConnectContext.iScanResponseFrameBody = aBody;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline const TUint8* WlanContextImpl::ScanResponseFrameBody() const
    {
    return iConnectContext.iScanResponseFrameBody;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::SetScanResponseFrameBodyLength( TUint16 aLength )
    {
    iConnectContext.iScanResponseFrameBodyLength = aLength;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline const TUint16 WlanContextImpl::ScanResponseFrameBodyLength() const
    {
    return iConnectContext.iScanResponseFrameBodyLength;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::IeData( const TUint8* aIeData )
    {
    iConnectContext.iIeData = aIeData;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline const TUint8* WlanContextImpl::IeData() const
    {
    return iConnectContext.iIeData;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::IeDataLength( TUint16 aIeDataLength )
    {
    iConnectContext.iIeDataLength = aIeDataLength;    
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::RadioMeasurement() const
    {
    return iConnectContext.iRadioMeasurement;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::RadioMeasurement( TBool aRadioMeasurement )
    {
    iConnectContext.iRadioMeasurement = aRadioMeasurement;    
    }
// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TUint16 WlanContextImpl::IeDataLength() const
    {
    return iConnectContext.iIeDataLength;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::SetActivePrivacyModeFilter(
    WlanContextImpl& /*aCtxImpl*/,                                                            
    TEncryptionStatus aEncryptionStatus )
    {
    iPrivacyModeFilters.SetActiveFilter( aEncryptionStatus );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::ExecuteActivePrivacyModeFilter(
    const SDataFrameHeader& aFrameheader, 
    TBool aUserDataEnabled, 
    TUint16 aEthernetType,
    TBool aUnicastKeyExists, 
    TBool aAesOrTkipOrWapiEncrypted ) const
    {
    return iPrivacyModeFilters.ExecuteFilter(
        aFrameheader, 
        aUserDataEnabled, 
        aEthernetType,
        aUnicastKeyExists, 
        aAesOrTkipOrWapiEncrypted );    
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline SCapabilityInformationField& 
WlanContextImpl::GetCapabilityInformation() 
    {
    return iConnectContext.iCapabilityInformation;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::OnConsecutiveBeaconsLost()
    {
    TBool ret( EFalse );

    if ( !iConsecutiveBeaconsLostIndicated )
        {
        iConsecutiveBeaconsLostIndicated = ETrue;
        ret = ETrue;        
        }

    return ret;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::OnConsecutiveTxFailures()
    {
    TBool ret( EFalse );

    if ( !iConsecutiveTxFailuresIndicated )
        {
        iConsecutiveTxFailuresIndicated = ETrue;
        ret = ETrue;        
        }

    return ret;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::OnConsecutivePwrModeSetFailures()
    {
    TBool ret( EFalse );

    if ( !iConsecutivePwrModeSetFailuresIndicated )
        {
        iConsecutivePwrModeSetFailuresIndicated = ETrue;
        ret = ETrue;        
        }

    return ret;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::ResetBssLossIndications()
    {
    iConsecutiveBeaconsLostIndicated = EFalse;
    iConsecutiveTxFailuresIndicated = EFalse;
    iConsecutivePwrModeSetFailuresIndicated = EFalse;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline SSupportedRatesIE& WlanContextImpl::GetApSupportedRatesIE() 
    {
    return iConnectContext.iApSupportedRates;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline SExtendedSupportedRatesIE& WlanContextImpl::GetApExtendedSupportedRatesIE() 
    {
    return iConnectContext.iApExtendedSupportedRates;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::ResetTxRateAdaptation()
    {
    iTxRateAdaptation.Reset();
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TUint32& WlanContextImpl::GetMinBasicRate()
    {
    return iConnectContext.iNwsaMinBasicRate;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TUint32& WlanContextImpl::GetMaxBasicRate()
    {
    return iConnectContext.iNwsaMaxBasicRate;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::ClearBasicRateSet()
    {
    iConnectContext.iNwsaBasicRateSet = 0;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::BasicRateSetBitSet( 
    const TUint32 aRateBitToSet )
    {
    iConnectContext.iNwsaBasicRateSet |= aRateBitToSet;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TUint32 WlanContextImpl::BasicRateSet() const
    {
    return iConnectContext.iNwsaBasicRateSet;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline WHA::TOperationMode WlanContextImpl::NetworkOperationMode() const
    {
    return iConnectContext.iOperationMode;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::NetworkOperationMode( 
    WHA::TOperationMode aOperationMode )
    {
    iConnectContext.iOperationMode = aOperationMode;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline const TPairwiseKeyData* WlanContextImpl::RoamingPairwiseKey() const
    {
    return iConnectContext.iRoamingPairwiseKey;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::RoamingPairwiseKey( 
    const TPairwiseKeyData* aKeyData )
    {
    iConnectContext.iRoamingPairwiseKey = aKeyData;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::GroupKeyType( 
    WHA::TKeyType aKeyType )
    {
    iConnectContext.iGroupKeyType = aKeyType;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline WHA::TKeyType WlanContextImpl::GroupKeyType() const
    {
    return iConnectContext.iGroupKeyType;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::PairWiseKeyType( 
    WHA::TKeyType aKeyType )
    {
    iConnectContext.iPairWiseKeyType = aKeyType;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline WHA::TKeyType WlanContextImpl::PairWiseKeyType() const
    {
    return iConnectContext.iPairWiseKeyType;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::PairwiseCipher( TWlanCipherSuite aCipherSuite )
    {
    iConnectContext.iPairwiseCipher = aCipherSuite;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TWlanCipherSuite WlanContextImpl::PairwiseCipher() const
    {
    return iConnectContext.iPairwiseCipher;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline WHA::TChannelNumber WlanContextImpl::NetworkChannelNumeber() const
    {
    return iConnectContext.iChannelNumber;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::NetworkChannelNumeber( 
    WHA::TChannelNumber aChannelNumber )
    {
    iConnectContext.iChannelNumber = aChannelNumber;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TUint32 WlanContextImpl::NetworkBeaconInterval() const
    {
    return iConnectContext.iBeaconInterval;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::NetworkBeaconInterval( 
    TUint32 aBeaconInterval )
    {
    iConnectContext.iBeaconInterval = aBeaconInterval;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline WHA::TPsMode WlanContextImpl::DesiredDot11PwrMgmtMode() const
    {
    return iConnectContext.iDesiredDot11PwrMgmtMode;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::DesiredDot11PwrMgmtMode( 
    WHA::TPsMode aPsMode )
    {
    iConnectContext.iDesiredDot11PwrMgmtMode = aPsMode;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline WHA::TPsMode WlanContextImpl::CurrentDot11PwrMgmtMode() const
    {
    return iConnectContext.iCurrentDot11PwrMgmtMode;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::CurrentDot11PwrMgmtMode( 
    WHA::TPsMode aPsMode )
    {
    iConnectContext.iCurrentDot11PwrMgmtMode = aPsMode;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline const TDot11PsModeWakeupSetting& 
    WlanContextImpl::DesiredPsModeConfig() const
    {
    return iConnectContext.iDesiredPsModeConfig;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::SetDesiredPsModeConfig(
    const TDot11PsModeWakeupSetting& aPsModeWakeupSetting )
    {
    iConnectContext.iDesiredPsModeConfig = aPsModeWakeupSetting;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline WHA::TPsMode WlanContextImpl::ClientDot11PwrMgmtMode() const
    {
    return iConnectContext.iClientDesiredDot11PwrMgtMode;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::ClientDot11PwrMgmtMode( 
    TPowerMode aPsMode )
    {
    iConnectContext.iClientDesiredDot11PwrMgtMode = 
        static_cast<WHA::TPsMode>(aPsMode);
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline const TDot11PsModeWakeupSetting& 
    WlanContextImpl::ClientLightPsModeConfig() const
    {
    return iConnectContext.iClientLightPsModeConfig;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::SetClientLightPsModeConfig( 
    TWlanWakeUpInterval aWakeupMode, 
    TUint8 aListenInterval )
    {
    iConnectContext.iClientLightPsModeConfig.iWakeupMode = aWakeupMode;
    iConnectContext.iClientLightPsModeConfig.iListenInterval = aListenInterval;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline const TDot11PsModeWakeupSetting&
    WlanContextImpl::ClientDeepPsModeConfig() const
    {
    return iConnectContext.iClientDeepPsModeConfig;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::SetClientDeepPsModeConfig( 
    TWlanWakeUpInterval aWakeupMode, 
    TUint8 aListenInterval )
    {
    iConnectContext.iClientDeepPsModeConfig.iWakeupMode = aWakeupMode;
    iConnectContext.iClientDeepPsModeConfig.iListenInterval = aListenInterval;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::DynamicPwrModeMgtDisabled() const
    {
    return ( iConnectContext.iFlags & 
             WlanConnectContext::KDynamicPwrModeMgmtDisabled );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::UseShortPreamble() const
    {
    return (iConnectContext.iFlags & WlanConnectContext::KUseShortPreamble);
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::Reassociate() const
    {
    return (iConnectContext.iFlags & WlanConnectContext::KReassociate);
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::UseShortSlotTime() const
    {
    return (iConnectContext.iFlags & WlanConnectContext::KUseShortSlotTime);
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::ProtectionBitSet() const
    {
    return (iConnectContext.iFlags & WlanConnectContext::KProtectionBitSet);
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::QosEnabled() const
    {
    return (iConnectContext.iFlags & WlanConnectContext::KQosEnabled);
    }
    
// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::UapsdEnabled() const
    {
    return (iConnectContext.iFlags & WlanConnectContext::KUapsdEnabled);
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::MulticastFilteringDisAllowed() const
    {
    return (iConnectContext.iFlags & WlanConnectContext::KMulticastFilteringDisAllowed);    
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::ErpIePresent() const
    {
    return (iConnectContext.iFlags & WlanConnectContext::KErpIePresent);
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::DisassociatedByAp() const
    {
    return (iConnectContext.iFlags & WlanConnectContext::KDisassociatedByAp);
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::UapsdRequestedForVoice() const
    {
    return ( iConnectContext.iFlags & 
             WlanConnectContext::KUapsdRequestedForVoice );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::UapsdRequestedForVideo() const
    {
    return ( iConnectContext.iFlags & 
             WlanConnectContext::KUapsdRequestedForVideo );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::UapsdRequestedForBestEffort() const
    {
    return ( iConnectContext.iFlags & 
             WlanConnectContext::KUapsdRequestedForBestEffort );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::UapsdRequestedForBackground() const
    {
    return ( iConnectContext.iFlags & 
             WlanConnectContext::KUapsdRequestedForBackground );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::UapsdUsedForVoice() const
    {
    return ( iConnectContext.iFlags & 
             WlanConnectContext::KUapsdUsedForVoice );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::UapsdUsedForVideo() const
    {
    return ( iConnectContext.iFlags & 
             WlanConnectContext::KUapsdUsedForVideo );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::UapsdUsedForBestEffort() const
    {
    return ( iConnectContext.iFlags & 
             WlanConnectContext::KUapsdUsedForBestEffort );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::UapsdUsedForBackground() const
    {
    return ( iConnectContext.iFlags & 
             WlanConnectContext::KUapsdUsedForBackground );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::ApTestOpportunitySeekStarted() const
    {
    return ( iConnectContext.iFlags & 
             WlanConnectContext::KApTestOpportunitySeekStarted );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::ApTestOpportunityIndicated() const
    {
    return ( iConnectContext.iFlags & 
             WlanConnectContext::KApTestOpportunityIndicated );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::HtSupportedByNw() const
    {
    return ( iConnectContext.iFlags & 
             WlanConnectContext::KHtSupportedByNw );    
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TUint8 WlanContextImpl::WmmParameterSetCount() const
    {
    return iConnectContext.iWmmParamSetCount;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::WmmParameterSetCount( TUint8 aValue )
    {
    iConnectContext.iWmmParamSetCount = aValue;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TUint32 WlanContextImpl::RateBitMask() const
    {
    return iConnectContext.iRateBitMask;
    }
    
// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::RateBitMask( TUint32 aValue )
    {
    iConnectContext.iRateBitMask = aValue;
    }
    
// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TCwMinVector& WlanContextImpl::CwMinVector()
    {
    return iConnectContext.iCwMin;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TCwMaxVector& WlanContextImpl::CwMaxVector()
    {
    return iConnectContext.iCwMax;    
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TAifsVector& WlanContextImpl::AifsVector()
    {
    return iConnectContext.iAIFS;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TTxOplimitVector& WlanContextImpl::TxOplimitVector()
    {
    return iConnectContext.iTxOplimit;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TAcmVector& WlanContextImpl::AcmVector()
    {
    return iConnectContext.iAdmCtrlMandatory;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline STxWmmIE& WlanContextImpl::OurWmmIe()
    {
    return iConnectContext.iOurWmmIe;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TTxRatePolicy& WlanContextImpl::RatePolicy()
    {
    return iConnectContext.iRatePolicy;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TQueue2RateClass& WlanContextImpl::Queue2RateClass()
    {
    return iConnectContext.iQueue2RateClass;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TInitialMaxTxRate4RateClass& 
WlanContextImpl::InitialMaxTxRate4RateClass()
    {
    return iConnectContext.iInitialMaxTxRate4RateClass;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TTxAutoRatePolicy& WlanContextImpl::AutoRatePolicy()
    {
    return iConnectContext.iAutoRatePolicy;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TUint8 WlanContextImpl::SpecialTxAutoRatePolicy() const
    {
    return iConnectContext.iSpecialTxRatePolicyId;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::SpecialTxAutoRatePolicy( TUint8 aPolicyId )
    {
    iConnectContext.iSpecialTxRatePolicyId = aPolicyId;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline THtMcsPolicy& WlanContextImpl::HtMcsPolicy()
    {
    return iConnectContext.iHtMcsPolicy;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TQosInfoUapsdMaxSpLen& WlanContextImpl::UapsdMaxSpLen()
    {
    return iConnectContext.iUapsdMaxSpLen;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::WsaCmdActive() const
    {
    return iWsaCmdActive;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::ActivateWsaCmd()
    {
    iWsaCmdActive = ETrue;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::DeActivateWsaCmd()
    {
    iWsaCmdActive = EFalse;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::IncrementAuthSeqNmbrExpected()
    {
    ++iAuthSeqNmbrExpected;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::SetTxRateAdaptationRates( 
    TUint8 aPolicyId,
    WHA::TRate aRateBitmask )
    {
    return iTxRateAdaptation.SetRates( aPolicyId, aRateBitmask );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::SetTxRatePolicy( WHA::TQueueId aQueueId, TUint8 aPolicyId )
    {
    iTxRateAdaptation.SetPolicy( aQueueId, aPolicyId );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::SetCurrentMaxTxRate( 
    TUint8 aPolicyId, 
    WHA::TRate aRate )
    {
    iTxRateAdaptation.SetCurrentMaxTxRate( aPolicyId, aRate );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::SetTxRateAdaptationAlgorithmParams( 
    TUint8 aMinStepUpCheckpoint,
    TUint8 aMaxStepUpCheckpoint,
    TUint8 aStepUpCheckpointFactor,
    TUint8 aStepDownCheckpoint,
    TUint8 aMinStepUpThreshold,
    TUint8 aMaxStepUpThreshold,
    TUint8 aStepUpThresholdIncrement,
    TUint8 aStepDownThreshold,
    TBool aDisableProbeHandling )
    {
    iTxRateAdaptation.SetAlgorithmParameters(
        aMinStepUpCheckpoint,
        aMaxStepUpCheckpoint,
        aStepUpCheckpointFactor,
        aStepDownCheckpoint,
        aMinStepUpThreshold,
        aMaxStepUpThreshold,
        aStepUpThresholdIncrement,
        aStepDownThreshold,
        aDisableProbeHandling );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TUint32 WlanContextImpl::Random()
    {
    return iPrnGenerator.Generate();
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TUint32 WlanContextImpl::WhaCommandAct() const
    {
    return iWhaCommandAct;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::WhaCommandAct( TUint32 aAct )
    {
    iWhaCommandAct = aAct;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::RegisterEvent( const TOIDHeader& aOid )
    {
    iEventDispatcher.Register( aOid );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::RegisterEvent( TInternalEvent aInternalEvent )
    {
    iEventDispatcher.Register( aInternalEvent );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::ChannelEnabled( 
    WlanEventDispatcher::TChannel aChannel ) const
    {
    return iEventDispatcher.ChannelEnabled( aChannel );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::Enable( 
    WlanEventDispatcher::TChannel aChannelMask )
    {
    iEventDispatcher.Enable( aChannelMask );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::Disable( 
    WlanEventDispatcher::TChannel aChannelMask )
    {
    iEventDispatcher.Disable( aChannelMask );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::DispatchEvent()
    {
    return iEventDispatcher.Dispatch();
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::CommandCompletionEventRegistered( 
    WHA::TCompleteCommandId aCommandId ) const
    {
    return iEventDispatcher.CommandCompletionRegistered( aCommandId );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::DispatchCommandCompletionEvent()
    {
    return iEventDispatcher.DispatchCommandCompletionEvent();
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::ProtocolStackTxDataAllowed() const
    {
    return iEnableUserData;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::PushPacketToPacketScheduler( 
    const TAny* aPacket, 
    TUint32 aLength, 
    WHA::TQueueId aQueueId,
    TUint32 aPacketId,
    const TDataBuffer* aMetaHeader,
    TBool aMore,
    TBool aMulticastData,
    TBool aUseSpecialRatePolicy )
    {
    return iPacketScheduler.Push( 
        *this, 
        aPacket, 
        aLength,
        aQueueId,
        aPacketId,
        aMetaHeader,
        aMore,
        aMulticastData,
        aUseSpecialRatePolicy );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::FlushPacketScheduler()
    {
    iPacketScheduler.Flush( *this );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::SchedulePackets( TBool aMore )
    {
    iPacketScheduler.SchedulePackets( *this, aMore );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::UnsentTxPackets() const
    {
    return iPacketScheduler.UnsentPackets();
    }
    
// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::IncrementFailedTxPacketCount()
    {
    ++iFailedTxPacketCount;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TUint8 WlanContextImpl::FailedTxPacketCount() const
    {
    return iFailedTxPacketCount;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::ResetFailedTxPacketCount()
    {
    iFailedTxPacketCount = 0;
    }

// ---------------------------------------------------------------------------
// We use the failed Tx packet count threshold as the threshold value
// in this case, too - as informing AP about a power mgmt mode change
// also involves a frame Tx
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::InitializeSetPsModeCount()
    {
    iSetPsModeCount = iWlanMib.iFailedTxPacketCountThreshold;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::DecrementSetPsModeCount()
    {
    --iSetPsModeCount;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TUint WlanContextImpl::SetPsModeCount() const
    {
    return iSetPsModeCount;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::StartPowerModeManagement()
    {
    iDynamicPowerModeCntx.StartPowerModeManagement();
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::StopPowerModeManagement()
    {
    iDynamicPowerModeCntx.StopPowerModeManagement();
    }
                
// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TPowerMgmtModeChange WlanContextImpl::OnFrameTx( 
    WHA::TQueueId aQueueId,
    TUint16 aEtherType )
    {
    return iDynamicPowerModeCntx.OnFrameTx( aQueueId, aEtherType );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TPowerMgmtModeChange WlanContextImpl::OnFrameRx(
    WHA::TQueueId aAccessCategory,
    TUint16 aEtherType,
    TUint aPayloadLength,
    TDaType aDaType )
    {
    return iDynamicPowerModeCntx.OnFrameRx( 
        aAccessCategory, 
        aEtherType,
        aPayloadLength, 
        aDaType );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::SetPowerModeManagementParameters(
    TUint32 aToLightPsTimeout,
    TUint16 aToLightPsFrameThreshold,
    TUint32 aToActiveTimeout,
    TUint16 aToActiveFrameThreshold,
    TUint32 aToDeepPsTimeout,
    TUint16 aToDeepPsFrameThreshold,
    TUint16 aUapsdRxFrameLengthThreshold )
    {
    iDynamicPowerModeCntx.SetParameters(
        aToLightPsTimeout,
        aToLightPsFrameThreshold,
        aToActiveTimeout,
        aToActiveFrameThreshold,
        aToDeepPsTimeout,
        aToDeepPsFrameThreshold,
        aUapsdRxFrameLengthThreshold );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::ConfigurePwrModeMgmtTrafficOverride( 
    TBool aStayInPsDespiteUapsdVoiceTraffic,
    TBool aStayInPsDespiteUapsdVideoTraffic,
    TBool aStayInPsDespiteUapsdBestEffortTraffic, 
    TBool aStayInPsDespiteUapsdBackgroundTraffic,
    TBool aStayInPsDespiteLegacyVoiceTraffic,
    TBool aStayInPsDespiteLegacyVideoTraffic,
    TBool aStayInPsDespiteLegacyBestEffortTraffic,
    TBool aStayInPsDespiteLegacyBackgroundTraffic )
    {
    iDynamicPowerModeCntx.ConfigureTrafficOverride( 
        aStayInPsDespiteUapsdVoiceTraffic,
        aStayInPsDespiteUapsdVideoTraffic,
        aStayInPsDespiteUapsdBestEffortTraffic, 
        aStayInPsDespiteUapsdBackgroundTraffic,
        aStayInPsDespiteLegacyVoiceTraffic,
        aStayInPsDespiteLegacyVideoTraffic,
        aStayInPsDespiteLegacyBestEffortTraffic,
        aStayInPsDespiteLegacyBackgroundTraffic );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::FreezePwrModeMgmtTrafficOverride()
    {
    iDynamicPowerModeCntx.FreezeTrafficOverride();
    }
                    
// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::OnActiveToLightPsTimerTimeout()
    {
    return iDynamicPowerModeCntx.OnActiveToLightPsTimerTimeout();
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::OnLightPsToActiveTimerTimeout()
    {
    return iDynamicPowerModeCntx.OnLightPsToActiveTimerTimeout();
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::OnLightPsToDeepPsTimerTimeout()
    {
    return iDynamicPowerModeCntx.OnLightPsToDeepPsTimerTimeout();
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline WlanContextImpl::TGroupAddStatus WlanContextImpl::AddMulticastAddress( 
        const TMacAddress& aMacAddress )
    {
    return iJoinedMulticastGroups.AddGroup( aMacAddress );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::RemoveMulticastAddress( const TMacAddress& aMacAddress )
    {
    return iJoinedMulticastGroups.RemoveGroup( aMacAddress );    
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TUint8 WlanContextImpl::MulticastAddressCount() const
    {
    return iJoinedMulticastGroups.Count();
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TUint8 WlanContextImpl::GetMulticastAddresses( 
    const TMacAddress*& aMacAddresses ) const
    {
    return iJoinedMulticastGroups.GetGroups( aMacAddresses );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::ResetMulticastAddresses()
    {
    iJoinedMulticastGroups.Reset();
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::MarkInternalTxBufFree()
    {
    iInternalTxBufFree = ETrue;

    OsTracePrint( KUmacDetails, (TUint8*)
        ("UMAC: WlanContextImpl::MarkInternalTxBufFree: buffer free again"));
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::InternalTxBufBeingWaited() const
    {
    return iInternalTxBufBeingWaited;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::ClearInternalTxBufBeingWaitedFlag()
    {
    iInternalTxBufBeingWaited = EFalse;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::ResetFrameStatistics()
    {
    os_memset( &iFrameStatistics, 0, sizeof( iFrameStatistics ) );    
    }


// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::IncrementRxUnicastDataFrameCount( 
    WHA::TQueueId aAccessCategory )
    {
    ++iFrameStatistics.acSpecific[aAccessCategory].rxUnicastDataFrameCount;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::IncrementTxUnicastDataFrameCount(
    WHA::TQueueId aAccessCategory )
    {
    ++iFrameStatistics.acSpecific[aAccessCategory].txUnicastDataFrameCount;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::IncrementRxMulticastDataFrameCount(
    WHA::TQueueId aAccessCategory )
    {
    ++iFrameStatistics.acSpecific[aAccessCategory].rxMulticastDataFrameCount;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::IncrementTxMulticastDataFrameCount(
    WHA::TQueueId aAccessCategory)
    {
    ++iFrameStatistics.acSpecific[aAccessCategory].txMulticastDataFrameCount;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::IncrementTxRetryCount( 
    WHA::TQueueId aAccessCategory,
    TUint aCount )
    {
    iFrameStatistics.acSpecific[aAccessCategory].txRetryCount += aCount;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::IncrementTxErrorCount( 
    WHA::TQueueId aAccessCategory )
    {
    ++iFrameStatistics.acSpecific[aAccessCategory].txErrorCount;
    }

// ---------------------------------------------------------------------------
// Note! We use the Tx Media Delay field first to collect the
// cumulative Media Delay. The average Media Delay is then calculated at the 
// point of reporting the frame statistics results to WLAN Mgmt client
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::IncrementTxMediaDelay( 
    WHA::TQueueId aAccessCategory,
    TUint aDelay )
    {
    iFrameStatistics.acSpecific[aAccessCategory].txMediaDelay += aDelay;
    }

// ---------------------------------------------------------------------------
// Note! We use the Total Tx Delay field first to collect the
// cumulative Total Tx Delay. The average Total Tx Delay is then calculated 
// at the point of reporting the frame statistics results to WLAN Mgmt client
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::IncrementTotalTxDelay( 
    WHA::TQueueId aAccessCategory,
    TUint aDelay )
    {
    iFrameStatistics.acSpecific[aAccessCategory].totalTxDelay += aDelay;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::StoreFcsErrorCount( TUint aCount )
    {
    iFrameStatistics.fcsErrorCount = aCount;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline const TStatisticsResponse& WlanContextImpl::FrameStatistics() const
    {
    return iFrameStatistics;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::SetNullSendControllerParameters(
    TUint32 aVoiceCallEntryTimeout,
    TUint32 aVoiceCallEntryTxThreshold,
    TUint32 aNullTimeout,
    TUint32 aNoVoiceTimeout,
    TUint32 aKeepAliveTimeout )
    {
    iNullSendController.SetParameters( 
        aVoiceCallEntryTimeout,
        aVoiceCallEntryTxThreshold,
        aNullTimeout, 
        aNoVoiceTimeout, 
        aKeepAliveTimeout );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::StartVoiceOverWlanCallMaintenance()
    {
    iNullSendController.StartVoiceOverWlanCallMaintenance();
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::StopVoiceOverWlanCallMaintenance()
    {
    iNullSendController.StopVoiceOverWlanCallMaintenance();
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::TerminateVoiceOverWlanCallMaintenance()
    {
    iNullSendController.TerminateVoiceOverWlanCallMaintenance();
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::ResumeQosNullSending()
    {
    iNullSendController.ResumeQosNullSending();
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::StartKeepAlive()
    {
    iNullSendController.StartKeepAlive();
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::StopKeepAlive()
    {
    iNullSendController.StopKeepAlive();
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::OnDataRxCompleted( 
    WHA::TQueueId aQueueId,
    TUint aPayloadLength )
    {
    iNullSendController.OnFrameRx( aQueueId, aPayloadLength );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::OnDataTxCompleted( WHA::TQueueId aQueueId )
    {
    iNullSendController.OnFrameTx( aQueueId );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::OnQosNullDataTxCompleted()
    {
    iNullSendController.OnQosNullDataTxCompleted();
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::OnNullDataTxCompleted()
    {
    iNullSendController.OnNullDataTxCompleted();
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::OnVoiceCallEntryTimerTimeout()
    {
    iNullSendController.OnVoiceCallEntryTimerTimeout();
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::OnNullTimerTimeout()
    {
    iNullSendController.OnNullTimerTimeout();
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::OnNoVoiceTimerTimeout()
    {
    iNullSendController.OnNoVoiceTimerTimeout();
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::OnKeepAliveTimerTimeout()
    {
    iNullSendController.OnKeepAliveTimerTimeout();
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::InsertNewRcpiIntoPredictor( 
    TInt64 aTimestamp, 
    WHA::TRcpi aRcpi )
    {
    return iWlanSignalPredictor.InsertNewRcpi( 
        // this cast is ok as the predictor is prepared for the possibility 
        // of the lower (TUint32) part of the timestamp rolling around
        static_cast<TUint32>(aTimestamp), 
        aRcpi );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::GetLatestMedianRcpiFromPredictor( 
    TInt64 aTimestamp,
    WHA::TRcpi& aLatestMedian ) const
    {
    return iWlanSignalPredictor.GetLatestMedian( 
        // this cast is ok as the predictor is prepared for the possibility 
        // of the lower (TUint32) part of the timestamp rolling around
        static_cast<TUint32>(aTimestamp),
        aLatestMedian );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanContextImpl::ConfigureWlanSignalPredictor(
    TUint32 aTimeToWarnLevel,
    TUint32 aTimeToNextInd,
    WHA::TRcpi aRcpiWarnLevel)
    {
    iWlanSignalPredictor.ConfigureSignalPredictor( 
        aTimeToWarnLevel,
        aTimeToNextInd,
        aRcpiWarnLevel );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline SHtCapabilitiesIE& WlanContextImpl::GetOurHtCapabilitiesIe()
    {
    return iOurHtCapabilitiesIe;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline SHtCapabilitiesIE& WlanContextImpl::GetNwHtCapabilitiesIe()
    {
    return iConnectContext.iNwHtCapabilitiesIe;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline SHtOperationIE& WlanContextImpl::GetNwHtOperationIe()
    {
    return iConnectContext.iNwHtOperationIe;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline WHA::ShtBlockAckConfigure& WlanContextImpl::GetHtBlockAckConfigure()
    {
    return iHtBlockAckConfigure;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline SSnapHeader& WlanContextImpl::GetProprietarySnapHeader()
    {
    return iProprietarySnapHeader;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanContextImpl::GetWhaTxStatus( 
    TWhaTxQueueState& aTxQueueState ) const
    {
    return iPacketScheduler.GetWhaTxStatus( *this, aTxQueueState );
    }