// Copyright (c) 2010 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:

//

/**

 @file

 @internalComponent

*/

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "pdp_contentionTraces.h"

#endif

#include <pdpmcpr.h>

#include <pdp_contention.h>

#include <mbmsengine.h>

#include <etelpckt.h>

#include <pcktcs.h>

CContextTypeChecker::CContextTypeChecker(RPacketService& aPacketService, MContextEventsObserver& aCallback):CActive(EPriorityStandard),

    iPacketService(aPacketService), iCallback(aCallback)

    {

    CActiveScheduler::Add(this);

    }

CContextTypeChecker::~CContextTypeChecker()

    {

    iContextName = NULL;

    }

void CContextTypeChecker::Start(const TName* aContextName)

    {

    iContextName = aContextName;

    iPacketService.EnumerateContextsInNif(iStatus, *iContextName, iCountInNif);

    SetActive();

    }

void CContextTypeChecker::RunL()

    {

    User::LeaveIfError(iStatus.Int());

    if (iCountInNif == 1) // This is a primary context

        {

        iCallback.PrimaryContextAddedL(iContextName);

        }

    else

        {

        iCallback.SecondaryContextAdded(iContextName);

        }

    }

void CContextTypeChecker::DoCancel()

    {

    iPacketService.CancelAsyncRequest(EPacketEnumerateContextsInNif);

    }

TInt CContextTypeChecker::RunError(TInt aError)

    {

    // Report an error

    iCallback.ContextTypeCheckingError(iContextName, aError);

    return KErrNone; // Make ActiveScheduler happy

    }

CPrimaryContextsMonitor::CPrimaryContextsMonitor(RPacketService& aPacketService, MContentionObserver& aCallback) : CActive(EPriorityStandard),

    iPacketService(aPacketService), iCallback(aCallback)

    {

    CActiveScheduler::Add(this);

    }

CPrimaryContextsMonitor::~CPrimaryContextsMonitor()

    {

    Cancel();

    iContextMonitors.ResetAndDestroy();

    delete iContextTypeChecker;

    iAddedContextsNames.ResetAndDestroy();

    }

void CPrimaryContextsMonitor::StartL()

    {

    iContextTypeChecker = new(ELeave) CContextTypeChecker(iPacketService, *this);

    iState = EEnumeratingContexts;

    iPacketService.EnumerateNifs(iStatus, iInitialNifsCount);

    SetActive();

    }

void CPrimaryContextsMonitor::PrimaryContextAddedL(const TName* aContextName)

    {

    // Create new status monitor for this context

    StartContextStatusMonitoringL(*aContextName);

    RemoveContextNameAndCheckNext(aContextName);

    }

void CPrimaryContextsMonitor::SecondaryContextAdded(const TName* aContextName)

    {

    // This is not a primary context, just delete its name.

    RemoveContextNameAndCheckNext(aContextName);

    }

void CPrimaryContextsMonitor::RemoveContextNameAndCheckNext(const TName* aContextName)

    {

    TInt nameIndex = iAddedContextsNames.Find(aContextName);

    __ASSERT_DEBUG(nameIndex != KErrNotFound, User::Invariant());

    delete iAddedContextsNames[nameIndex];

    iAddedContextsNames.Remove(nameIndex);

    if (iAddedContextsNames.Count() > 1)

        // Should be more than one here, coz we are waiting for new context added all the time,

        // so the last one item is always empty.

        {

        iContextTypeChecker->Start(iAddedContextsNames[0]);

        }

    }

void CPrimaryContextsMonitor::PrimaryContextDeleted(const CContextStatusMonitor* aContextStatusMonitor)

    {

    if (aContextStatusMonitor->IsPassedThroughActiveState())

        {

        iCallback.ContentionResolved();

        }

    DeleteContextStatusMonitor(aContextStatusMonitor);

    }

void CPrimaryContextsMonitor::ContextTypeCheckingError(const TName* aContextName, TInt aError)

    {

    RemoveContextNameAndCheckNext(aContextName);

    ProcessError(aError);

    }

void CPrimaryContextsMonitor::ContextMonitoringError(const CContextStatusMonitor* aContextStatusMonitor, TInt aError)

    {

    DeleteContextStatusMonitor(aContextStatusMonitor);

    ProcessError(aError);

    }

void CPrimaryContextsMonitor::DeleteContextStatusMonitor(const CContextStatusMonitor* aContextStatusMonitor)

    {

    TInt monitorIndex = iContextMonitors.Find(aContextStatusMonitor);

    __ASSERT_DEBUG(monitorIndex != KErrNotFound, User::Invariant());

    delete iContextMonitors[monitorIndex];

    iContextMonitors.Remove(monitorIndex);

    }

void CPrimaryContextsMonitor::ProcessError(TInt aError)

    {

    __ASSERT_DEBUG(aError != KErrNone, User::Invariant());

    OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CPRIMARYCONTEXTSMONITOR_PROCESSERROR_1, ("PDP context monitoring error: %d"), aError);

    (void)aError;  //needed for debug builds 

    }

void CPrimaryContextsMonitor::RunL()

    {

    User::LeaveIfError(iStatus.Int());

    SwitchStateL();

    RPacketService::TNifInfoV2Pckg nifInfoV2Pckg(iCurrentNifInfo);

    switch(iState)

        {

        case EGettingInfo:

            StartContextStatusMonitoringL(iCurrentNifInfo.iContextName);

            iPacketService.GetNifInfo(iStatus, iCurrentNifIndex, nifInfoV2Pckg);

            ++iCurrentNifIndex;

            SetActive();

            break;

        case EListening:

            // All functions in RPacketService and RPacketContext,

            // that can be used to check if context is primary, are asynchronous.

            // We could not call them here, coz can miss some events from NotifyContextAdded

            // So subscribe to NotifyContextAdded as soon as possible and check context

            // type using CContextTypeChecker active object

            TName *contextName = new (ELeave) TName;

            CleanupStack::PushL(contextName);

            iAddedContextsNames.AppendL(contextName);

            CleanupStack::Pop(contextName);

            // subscribe to NotifyContextAdded

            iPacketService.NotifyContextAdded(iStatus, *contextName);

            SetActive();

            // if there are any items in iAddedContextsNames except that one that has been added above, i.e count > 1

            // starting asynchronous context type checking

            if (!iContextTypeChecker->IsActive() && iAddedContextsNames.Count()>1)

                {

                iContextTypeChecker->Start(iAddedContextsNames[0]);

                }

            break;

        }

    }

void CPrimaryContextsMonitor::DoCancel()

    {

    switch(iState)

        {

        case EEnumeratingContexts:

            iPacketService.CancelAsyncRequest(EPacketEnumerateNifs);

            break;

        case EGettingInfo:

            iPacketService.CancelAsyncRequest(EPacketGetNifInfo);

            break;

        case EListening:

            iPacketService.CancelAsyncRequest(EPacketNotifyContextAdded);

            break;

        }

    }

TInt CPrimaryContextsMonitor::RunError(TInt aError)

    {

    // Process an error

    ProcessError(aError);

    return KErrNone; // Make ActiveScheduler happy

    }

void CPrimaryContextsMonitor::SwitchStateL()

    {

    if (iState == EEnumeratingContexts)

        {

        if (iInitialNifsCount > 0)

            {

            iState = EGettingInfo;

            }

        else

            {

            iState = EListening;

            }

        }

    else if (iState == EGettingInfo && iCurrentNifIndex == iInitialNifsCount)

        {

        StartContextStatusMonitoringL(iCurrentNifInfo.iContextName);

        iState = EListening;

        }

    }

void CPrimaryContextsMonitor::StartContextStatusMonitoringL(const TName& aContextName)

    {

    CContextStatusMonitor* newStatusMonitor = new (ELeave) CContextStatusMonitor(iPacketService, *this);

    CleanupStack::PushL(newStatusMonitor);

    iContextMonitors.AppendL(newStatusMonitor);

    CleanupStack::Pop(newStatusMonitor);

    newStatusMonitor->StartL(aContextName);

    }

CContextStatusMonitor::CContextStatusMonitor(RPacketService& aPacketService, MContextEventsObserver& aCallback):CActive(EPriorityStandard),

    iPacketService(aPacketService), iCallback(aCallback)

    {

    CActiveScheduler::Add(this);

    }

CContextStatusMonitor::~CContextStatusMonitor()

    {

    Cancel();

    iPacketContext.Close();

    }

TBool CContextStatusMonitor::StartL(const TName& aContextName)

    {

    iContextName.Copy(aContextName);

    User::LeaveIfError(iPacketContext.OpenExistingContext(iPacketService, iContextName));

    User::LeaveIfError(iPacketContext.GetStatus(iContextStatus));

    if (iContextStatus == RPacketContext::EStatusDeleted)

        {

        return EFalse;

        }

    if (iContextStatus == RPacketContext::EStatusActive ||

        iContextStatus == RPacketContext::EStatusSuspended ||

        iContextStatus == RPacketContext::EStatusDeactivating)

        {

        iWasActive = ETrue;

        }

    iPacketContext.NotifyStatusChange(iStatus, iContextStatus);

    SetActive();

    return ETrue;

    }

void CContextStatusMonitor::RunL()

    {

    User::LeaveIfError(iStatus.Int());

    if (iContextStatus == RPacketContext::EStatusActive)

        {

        iWasActive = ETrue;

        }

    if (iContextStatus == RPacketContext::EStatusDeleted)

        {

        iPacketContext.CancelAsyncRequest(EPacketContextNotifyStatusChange);

        iCallback.PrimaryContextDeleted(this);

        }

    else

        {

        iPacketContext.NotifyStatusChange(iStatus, iContextStatus);

        SetActive();

        }

    }

void CContextStatusMonitor::DoCancel()

    {

    iPacketContext.CancelAsyncRequest(EPacketContextNotifyStatusChange);

    }

TInt CContextStatusMonitor::RunError(TInt aError)

    {

    iCallback.ContextMonitoringError(this, aError);

    return KErrNone;

    }

CPdpContentionManager* CPdpContentionManager::NewL(const ESock::CTierManagerBase& aTierManager, RPacketService& aPacketService)

    {

    CPdpContentionManager* self = new (ELeave) CPdpContentionManager(aTierManager);

    CleanupStack::PushL(self);

    self->ConstructL(aPacketService);

    CleanupStack::Pop(self);

    return self;

    }

CPdpContentionManager::CPdpContentionManager(const ESock::CTierManagerBase& aTierManager):

CContentionManager(aTierManager)

    {

    }

CPdpContentionManager::~CPdpContentionManager()

    {

    delete iPrimaryContextsMonitor;

    }

void CPdpContentionManager::ConstructL(RPacketService& aPacketService)

    {

    iPrimaryContextsMonitor = new (ELeave) CPrimaryContextsMonitor(aPacketService, *this);

    }

void CPdpContentionManager::StartMonitoringL()

    {

    if (iPrimaryContextsMonitor)

        {

        iPrimaryContextsMonitor->StartL();

        }

    }

void CPdpContentionManager::ContentionResolved(const TContentionRequestItem& aContentionRequest, TBool aResult)

    {

    CPdpMetaConnectionProvider* pdpMcpr = static_cast<CPdpMetaConnectionProvider*>(aContentionRequest.iMcpr);

    pdpMcpr->ContentionResolved(aContentionRequest.iPendingCprId, aResult);

    }

void CPdpContentionManager::ContentionOccured(ESock::CMetaConnectionProviderBase& aMcpr)

    {

    CPdpMetaConnectionProvider& pdpMcpr = static_cast<CPdpMetaConnectionProvider&>(aMcpr);

    pdpMcpr.ContentionOccured();

    }

void CPdpContentionManager::ReportContentionAvailabilityStatus(ESock::CMetaConnectionProviderBase& aMcpr, const ESock::TAvailabilityStatus& aStatus) const

    {

    CPdpMetaConnectionProvider& pdpMcpr = static_cast<CPdpMetaConnectionProvider&>(aMcpr);

    pdpMcpr.ReportContentionAvailabilityStatus(aStatus);

    }