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

// Implementation of CFilteringActiveScheduler and CActiveRetriever

// 

//

/**

 @file 

*/

#include "cctsyactiveretriever.h"

TInt CActiveRetriever::iSimultaneousRetrieveRequestsNumber(0);

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

// Implementation of CFilteringActiveScheduler

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

CFilteringActiveScheduler::~CFilteringActiveScheduler()

	{

	iRetrievers.Reset();

	}

//

void CFilteringActiveScheduler::AddRetrieverL(CActiveRetriever& aRetriever)

	{

	iRetrievers.AppendL(&aRetriever);

	}

//	

void CFilteringActiveScheduler::StartScheduler()

	{

	for (TInt i = 0; i<iRetrievers.Count(); i++)

		{

		if (iRetrievers[i]->IsActive())

			{

			// only if there is Active Retriever then actually starts Scheduler

			return CActiveScheduler::Start();

			}

		}

	}

//

void CFilteringActiveScheduler::WaitForAnyRequest()

	{

	do 	

		{

		CActiveScheduler::WaitForAnyRequest();

		}

	while (!IsOneOfMyRequestsComplete()); // WaitForAnyRequest while one of my requests is not complete 

	}

// check whether thera is any Retriever's request complete

TBool CFilteringActiveScheduler::IsOneOfMyRequestsComplete()

	{

	TBool ret(EFalse);

	for (TInt i = 0; i<iRetrievers.Count() && !ret; i++)

		{

		if (iRetrievers[i]->IsRequestComplete())

			{

			ret = ETrue;

			iRetrievers[i]->PerformCancelIfNeeded();

			}

		}

	return ret;

	}

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

// Implementation of CActiveRetriever

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

CActiveRetriever* CActiveRetriever::

			NewLC(CAsyncRetrieveVariableLengthBufferV2& aAsynchRetrieveBuffer)

    {

	CActiveRetriever* self =  new (ELeave) CActiveRetriever(aAsynchRetrieveBuffer);

	CleanupStack::PushL(self);

	return self;		

    }

//

CActiveRetriever* CActiveRetriever::

			NewL(CAsyncRetrieveVariableLengthBufferV2& aAsynchRetrieveBuffer)

    {

	return new (ELeave) CActiveRetriever(aAsynchRetrieveBuffer);

    }

//

CActiveRetriever::CActiveRetriever(CAsyncRetrieveVariableLengthBufferV2& aAsynchRetrieveBuffer) : 

    CActive(EPriorityStandard),

    iAsynchRetrieveBuffer(aAsynchRetrieveBuffer),

    iTestCase(ECaseNotSpecified),

    iPhase1Passed(EFalse)

    {

    CActiveScheduler::Add(this);

    }

//

CActiveRetriever::~CActiveRetriever()

    {

    Cancel();

    }

//

TBool CActiveRetriever::IsRequestComplete()

	{

	TBool ret(EFalse);

	if ( ( AsynchRetrieveBuffer().IsActive() && 

	       AsynchRetrieveBuffer().iStatus!=KRequestPending ) ||

	     ( IsActive() && iStatus!=KRequestPending) )

		{

		ret = ETrue;

		}

	return ret;

	}

//

void CActiveRetriever::PerformCancelIfNeeded()

	{

	if ( AsynchRetrieveBuffer().IsActive() && 

	     AsynchRetrieveBuffer().iStatus!=KRequestPending )

		{

		switch(TestCase())

			{

			case CActiveRetriever::ECasePhase2Cancel:

				if ( ! Phase1Passed() ) // cancel request after passing of 1st phase

					{

					SetPhase1Passed(ETrue);

					break;

					}

			case CActiveRetriever::ECasePhase1Cancel:

				AsynchRetrieveBuffer().Cancel();

				SetTestCase(CActiveRetriever::ECaseNotSpecified);

				break;

			case CActiveRetriever::ECaseNotSpecified:

			default:

				break;

			}

		}

	}

// resets pending requests number, STATIC 

TInt CActiveRetriever::ResetRequestsNumber()

	{

	TInt ret(iSimultaneousRetrieveRequestsNumber); 

	iSimultaneousRetrieveRequestsNumber = 0;

	return ret;

	}

//

TRequestStatus& CActiveRetriever::Status()

	{

	return iStatus;

	}

// AO's request function with test case parameter

void CActiveRetriever::Activate(TTestCase aTestCase)

    {

    if ( ECaseGeneralCancelCase != aTestCase )

    	{

        iTestCase = aTestCase;

        iSimultaneousRetrieveRequestsNumber++;

        SetActive();

    	}

    else

    	{

    	iAsynchRetrieveBuffer.Cancel();

	    iTestCase = ECaseNotSpecified;

    	}

    }

//   

void CActiveRetriever::RunL()

    {

    DoComplete(); // stops the Scheduler

    }

//

void CActiveRetriever::DoCancel()

    {

    if (IsActive())

	    {

	    iAsynchRetrieveBuffer.Cancel();

	    DoComplete();

	    }

    }

//

CActive& CActiveRetriever::AsynchRetrieveBuffer()

	{

	return iAsynchRetrieveBuffer;

	}

//

void CActiveRetriever::SetTestCase(CActiveRetriever::TTestCase aCase)

	{

	iTestCase = aCase;

	}

//	

CActiveRetriever::TTestCase CActiveRetriever::TestCase()

	{

	return iTestCase;

	}

//

void CActiveRetriever::SetPhase1Passed(TBool aPassed)

	{

	iPhase1Passed = aPassed;

	}

//	

TBool CActiveRetriever::Phase1Passed()

	{

	return iPhase1Passed;

	}

//

void CActiveRetriever::DoComplete()

	{

    if (!(--iSimultaneousRetrieveRequestsNumber))

	    {

    	CActiveScheduler::Stop();

    	}

	}