/*
* Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: Implements interaction with WLMServer for Admission control purpose
*
*/

/*
* %version: 7 %
*/

#include "NifWLMServerIf.h"
#include "WlanProto.h"
#include "am_debug.h"

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

// -----------------------------------------------------------------------------
// CLANNifWLMServerPerAC::NewL
// -----------------------------------------------------------------------------
//
CLANNifWLMServerPerAC* CLANNifWLMServerPerAC::NewL(
    TWlmAccessClass aAccessClass,
    TUint aInactivityTime,
    TBool aIsAutomaticMgmt )
    {
    DEBUG( "CLANNifWLMServerPerAC::NewL()" );
    CLANNifWLMServerPerAC* self =
        new (ELeave) CLANNifWLMServerPerAC( aAccessClass, aInactivityTime, aIsAutomaticMgmt );

    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );

    return self;
    }

// -----------------------------------------------------------------------------
// CLANNifWLMServerPerAC::CLANNifWLMServerPerAC
// -----------------------------------------------------------------------------
//
CLANNifWLMServerPerAC::CLANNifWLMServerPerAC(
    TWlmAccessClass aAccessClass,
    TUint aInactivityTime,
    TBool aIsAutomaticMgmt ):
    CActive( CActive::EPriorityStandard ),
    iAccessClass( aAccessClass ),
    iTrafficMode( EWlmAcTrafficModeAutomatic ),
    iTrafficStatus( EWlmAcTrafficStatusAdmitted ),
    iContext( ETSCreateRequest ),
    iIsTsCreated( EFalse ),
    iTsId( 0 ),
    iTsParams( KACtoUP[iAccessClass] ),
    iTsStatus( EWlanTrafficStreamStatusActive ),
    iTsInactivityTime( aInactivityTime ),
    iTsDelOrigTime( 0 ),
    iTsDelRemainTime( 0 ),
    iTsDelStartTime( 0 ),
    iIsAutomaticMgmt( aIsAutomaticMgmt )
    {
    DEBUG( "CLANNifWLMServerPerAC::CLANNifWLMServerPerAC()" );

    CActiveScheduler::Add(this);
    }

// -----------------------------------------------------------------------------
// CLANNifWLMServerPerAC::~CLANNifWLMServerPerAC
// -----------------------------------------------------------------------------
//
CLANNifWLMServerPerAC::~CLANNifWLMServerPerAC()
    {
    DEBUG( "CLANNifWLMServerPerAC::~CLANNifWLMServerPerAC()" );

    Cancel();
    iTsDelTimer.Close();
    iWlmServer.Close();
    }

// -----------------------------------------------------------------------------
// CLANNifWLMServerPerAC::ConstructL
// -----------------------------------------------------------------------------
//
void CLANNifWLMServerPerAC::ConstructL()
    {
    DEBUG( "CLANNifWLMServerPerAC::ConstructL()" );

    User::LeaveIfError( iWlmServer.Connect() );
    User::LeaveIfError( iTsDelTimer.CreateLocal() );
    }

// -----------------------------------------------------------------------------
// CLANNifWLMServerPerAC::IsAdmitted
// -----------------------------------------------------------------------------
//
TBool CLANNifWLMServerPerAC::IsAdmitted()
    {
    return ( iTrafficStatus == EWlmAcTrafficStatusAdmitted );
    }

// -----------------------------------------------------------------------------
// CLANNifWLMServerPerAC::SetTrafficMode
// -----------------------------------------------------------------------------
//
void CLANNifWLMServerPerAC::SetTrafficMode(
    TWlmAcTrafficMode aMode )
    {
    iTrafficMode = aMode;

    if( aMode == EWlmAcTrafficModeAutomatic )
        {
        DEBUG1( "CLANNifWLMServerPerAC::SetTrafficMode() - traffic mode set to automatic for AC %u",
            iAccessClass );
        }
    else if( aMode == EWlmAcTrafficModeManual )
        {
        DEBUG1( "CLANNifWLMServerPerAC::SetTrafficMode() - traffic mode set to manual for AC %u",
            iAccessClass );

        // If mode is changed from automatic to manual, it means NIF's
        // traffic streams for this AC have been deleted.

        Cancel();
        iIsTsCreated = EFalse;
        }
    }

// -----------------------------------------------------------------------------
// CLANNifWLMServerPerAC::SetTrafficStatus
// -----------------------------------------------------------------------------
//
void CLANNifWLMServerPerAC::SetTrafficStatus(
    TWlmAcTrafficStatus aStatus )
    {
    iTrafficStatus = aStatus;

    if( aStatus == EWlmAcTrafficStatusAdmitted )
        {
        DEBUG1( "CLANNifWLMServerPerAC::SetTrafficStatus() - traffic admitted on AC %u",
            iAccessClass );
        }
    else if( aStatus == EWlmAcTrafficModeManual )
        {
        DEBUG1( "CLANNifWLMServerPerAC::SetTrafficStatus() - traffic NOT admitted on AC %u",
            iAccessClass );
        }    
    }

// -----------------------------------------------------------------------------
// CLANNifWLMServerPerAC::SuspendInactivityTimer
// -----------------------------------------------------------------------------
//
void CLANNifWLMServerPerAC::SuspendInactivityTimer()
    {
    if( !iIsTsCreated )
        {
        DEBUG( "CLANNifWLMServerPerAC::SuspendInactivityTimer() - no traffic stream created, nothing to suspend" );

        return;        
        }    

    if( !IsActive() )
        {
        DEBUG( "CLANNifWLMServerPerAC::SuspendInactivityTimer() - timer is already suspended" );

        return;
        }

    DEBUG1( "CLANNifWLMServerPerAC::SuspendInactivityTimer() - AC: %u",
        iAccessClass );

    //First, cancel the running timer
    Cancel();

    TTime time;
    time.UniversalTime();
    TTimeIntervalMicroSeconds difference;
    difference = time.MicroSecondsFrom( iTsDelStartTime );
    iTsDelRemainTime = iTsDelRemainTime.Int() - difference.Int64();
    }

// -----------------------------------------------------------------------------
// CLANNifWLMServerPerAC::ResumeInactivityTimer
// -----------------------------------------------------------------------------
//
void CLANNifWLMServerPerAC::ResumeInactivityTimer()
    {
    if( !iIsTsCreated )
        {
        DEBUG( "CLANNifWLMServerPerAC::ResumeInactivityTimer() - no traffic stream created, nothing to resume" );

        return;        
        }

    if( IsActive() )
        {
        DEBUG( "CLANNifWLMServerPerAC::ResumeInactivityTimer() - timer is already resumed" );

        return;
        }    

    DEBUG2( "CLANNifWLMServerPerAC::ResumeInactivityTimer() - AC: %u, remaining time(us): %u",
        iAccessClass, iTsDelRemainTime.Int() );

    //Remember the time the timer is started
    iTsDelStartTime.UniversalTime();
    iTsDelTimer.After(iStatus, iTsDelRemainTime);
    SetActive();
    }

// -----------------------------------------------------------------------------
// CLANNifWLMServerPerAC::OnFrameSend
// -----------------------------------------------------------------------------
//
void CLANNifWLMServerPerAC::OnFrameSend()
    {
    DEBUG6( "CLanLinkCommon::OnFrameSend() - iAccessClass: %u, iTrafficStatus: %u, iTrafficMode: %u, iIsTsCreated: %u, iIsAutomaticMgmt: %u, IsActive(): %u",
        iAccessClass, iTrafficStatus, iTrafficMode, iIsTsCreated, iIsAutomaticMgmt, IsActive() );

    if( iIsAutomaticMgmt && 
        iTrafficStatus == EWlmAcTrafficStatusNotAdmitted &&
        iTrafficMode == EWlmAcTrafficModeAutomatic &&  
        !iIsTsCreated &&
        !IsActive() )
        {
        DEBUG1( "CLanLinkCommon::OnFrameSend() - requesting a virtual traffic stream for AC %u",
            iAccessClass );

        iWlmServer.CreateTrafficStream(
            iStatus,
            iTsParams,
            ETrue,
            iTsId,
            iTsStatus );
        iContext = ETSCreateRequest;
        SetActive();
        }
    else if( iIsTsCreated )
        {
        // Refresh the inactivity timer.

        Cancel();
        iTsDelRemainTime = iTsDelOrigTime;
        iTsDelStartTime.UniversalTime();
        iTsDelTimer.After( iStatus, iTsDelOrigTime );
        SetActive();
        }
    }

// -----------------------------------------------------------------------------
// CLANNifWLMServerPerAC::OnFrameReceive
// -----------------------------------------------------------------------------
//
void CLANNifWLMServerPerAC::OnFrameReceive()
    {
    DEBUG6( "CLanLinkCommon::OnFrameReceive() - iAccessClass: %u, iTrafficStatus: %u, iTrafficMode: %u, iIsTsCreated: %u, iIsAutomaticMgmt: %u, IsActive(): %u",
        iAccessClass, iTrafficStatus, iTrafficMode, iIsTsCreated, iIsAutomaticMgmt, IsActive() );
    
    if( iIsTsCreated &&
        IsActive() )
        {
        // Refresh the inactivity timer.

        Cancel();
        iTsDelRemainTime = iTsDelOrigTime;
        iTsDelStartTime.UniversalTime();
        iTsDelTimer.After( iStatus, iTsDelOrigTime );
        SetActive();
        }    
    }

// -----------------------------------------------------------------------------
// CLANNifWLMServerPerAC::RunL
// -----------------------------------------------------------------------------
//
void CLANNifWLMServerPerAC::RunL()
    {
    DEBUG1( "CLANNifWLMServerPerAC::RunL() - iStatus: %d",
        iStatus.Int() );

    if( iContext == ETSCreateRequest )
        {
        if( iStatus.Int() == KErrNone )
            {
            DEBUG1("CLANNifWLMServerPerAC::RunL() - virtual traffic stream successfully created for AC %u",
                iAccessClass );
            
            iIsTsCreated = ETrue;

            // Start the inactivity timer.
            iTsDelOrigTime = iTsDelRemainTime = iTsInactivityTime;
            iTsDelStartTime.UniversalTime();
            iContext = ETSDelTimer;
            iTsDelTimer.After( iStatus, iTsDelOrigTime );
            SetActive();
            }
        else
            {
            DEBUG2("CLANNifWLMServerPerAC::RunL() - virtual traffic stream creation for AC %u failed with %d",
                iAccessClass, iStatus.Int() );

            iIsTsCreated = EFalse;
            }
        }
    else if( iContext == ETSDelTimer )
        {
        DEBUG1( "CLANNifWLMServerPerAC::RunL() - inactivity timer expired for AC %u, deleting the virtual traffic stream",
            iAccessClass );

        iWlmServer.DeleteTrafficStream( iStatus, iTsId );
        User::WaitForRequest( iStatus );

        iIsTsCreated = EFalse;
        }
    }

// ---------------------------------------------------------------------------
// CLANNifWLMServerPerAC::RunError
// ---------------------------------------------------------------------------
//
TInt CLANNifWLMServerPerAC::RunError(
    TInt /* aError */ )
    {
    DEBUG( "CLANNifWLMServerPerAC::RunError()" );

    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CLANNifWLMServerPerAC::DoCancel
// -----------------------------------------------------------------------------
//
void CLANNifWLMServerPerAC::DoCancel()    
    {
    if( iContext == ETSCreateRequest )
        {
        DEBUG1( "CLANNifWLMServerPerAC::DoCancel() - cancelling TS create request for AC %u",
            iAccessClass );

        iWlmServer.CancelCreateTrafficStream();
        }
    else
        {
        DEBUG1( "CLANNifWLMServerPerAC::DoCancel() - cancelling TS delete timer for AC %u",
            iAccessClass );

        iTsDelTimer.Cancel();
        }
    }

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

// -----------------------------------------------------------------------------
// CLANNifWLMServerCommon::CLANNifWLMServerCommon
// -----------------------------------------------------------------------------
//
CLANNifWLMServerCommon::CLANNifWLMServerCommon(
    CLANLinkCommon* aLinkCommon ) :
    iLinkCommon( aLinkCommon )
    {
    DEBUG( "CLANNifWLMServerCommon::CLANNifWLMServerCommon()" );
    }

// -----------------------------------------------------------------------------
// CLANNifWLMServerCommon::~CLANNifWLMServerCommon
// -----------------------------------------------------------------------------
//
CLANNifWLMServerCommon::~CLANNifWLMServerCommon()
    {
    DEBUG( "CLANNifWLMServerCommon::~CLANNifWLMServerCommon" );

    iWlmServer.CancelNotifies();
    iWlmServer.Close();
    }

// -----------------------------------------------------------------------------
// CLANNifWLMServerCommon::ConstructL
// -----------------------------------------------------------------------------
//
void CLANNifWLMServerCommon::ConstructL()
    {
    DEBUG( "CLANNifWLMServerCommon::ConstructL()" );

    User::LeaveIfError( iWlmServer.Connect() );
    iWlmServer.ActivateNotifiesL(
        *this,
        EWlmNotifyAcTrafficModeChanged | EWlmNotifyAcTrafficStatusChanged );
    }

// -----------------------------------------------------------------------------
// CLANNifWLMServerCommon::GetAcTrafficStatus
// -----------------------------------------------------------------------------
//
TInt CLANNifWLMServerCommon::GetAcTrafficStatus(
    TWlmAcTrafficStatusArray& aArray )    
    {
    DEBUG( "CLANNifWLMServerCommon::GetAcTrafficStatus()" );

    return iWlmServer.GetAcTrafficStatus( aArray );
    }

// -----------------------------------------------------------------------------
// CLANNifWLMServerCommon::AccessClassTrafficModeChanged
// -----------------------------------------------------------------------------
//
void CLANNifWLMServerCommon::AccessClassTrafficModeChanged(
    TWlmAccessClass aAccessClass,
    TWlmAcTrafficMode aMode )
    {
    DEBUG( "CLANNifWLMServerCommon::AccessClassTrafficModeChanged()" );

    iLinkCommon->AcTrafficModeChanged(
        aAccessClass, aMode );
    }

// -----------------------------------------------------------------------------
// CLANNifWLMServerCommon::ConstructL
// -----------------------------------------------------------------------------
//
void CLANNifWLMServerCommon::AccessClassTrafficStatusChanged(
    TWlmAccessClass aAccessClass,
    TWlmAcTrafficStatus aStatus )
    {
    DEBUG( "CLANNifWLMServerCommon::AccessClassTrafficStatusChanged()" );

    iLinkCommon->AcTrafficStatusChanged(
        aAccessClass, aStatus );
    }