// 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:

//

#include <ssm/ssmswppolicy.h>

#include "ssmdebug.h"

#include "ssmswptransitionengine.h"

#include "ssmswptransitionscheduler.h"

#include "ssmswpindividualtransitionscheduler.h"

//

//Construction/Destruction

//

/**

Create a scheduler

*/

CSsmSwpTransitionScheduler* CSsmSwpTransitionScheduler::NewL()

	{

	CSsmSwpTransitionScheduler* self = NewLC();

	CleanupStack::Pop(self);

	return self;

	}

CSsmSwpTransitionScheduler* CSsmSwpTransitionScheduler::NewLC()

	{

	CSsmSwpTransitionScheduler* self = new (ELeave) CSsmSwpTransitionScheduler();

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

void CSsmSwpTransitionScheduler::ConstructL()

	{

	CTimer::ConstructL();

	CActiveScheduler::Add(this);

	}

LOCAL_C TInt OrderingFunction(const CSsmSwpIndividualTransitionScheduler& aLhs, const CSsmSwpIndividualTransitionScheduler& aRhs)

	{

	return aLhs.SwpKey() - aRhs.SwpKey();

	}

LOCAL_C TInt SearchingFunction(const TUint* aUint, const CSsmSwpIndividualTransitionScheduler& aObject)

	{

	return *aUint - aObject.SwpKey();

	}

CSsmSwpTransitionScheduler::CSsmSwpTransitionScheduler()

: CTimer(CActive::EPriorityStandard),

  iLinearOrder(&OrderingFunction)

	{

	}

/**

Deactivate

Destroy queue

*/

CSsmSwpTransitionScheduler::~CSsmSwpTransitionScheduler()

	{

	CTimer::Cancel();

	iIndividualTransitionSchedulers.ResetAndDestroy();

	}

/**

Take ownership of the transition engine and prepare it to run

@param aEngine - the engine to run

*/

void CSsmSwpTransitionScheduler::SubmitL(CSsmSwpTransitionEngine* aEngine)

	{

	if(!aEngine)

		{

		SSMLOGLEAVE(KErrArgument); //lint !e527 Suppress Unreachable. Lint is just confused by macro, warning goes away when code in macro gets expanded

		}

	CSsmSwpIndividualTransitionScheduler* scheduler = FindScheduler(aEngine);

	if(scheduler == NULL)

		{

		// No scheduler already for this SwP, need to create one

		scheduler = CSsmSwpIndividualTransitionScheduler::NewLC(aEngine->TransitionValue().Key(), aEngine->CleSessionProxy(), *this);

		iIndividualTransitionSchedulers.InsertInOrderL(scheduler, iLinearOrder);

		CleanupStack::Pop(scheduler);

		// Submit the request

		scheduler->SubmitL(aEngine);

		}

	else

		{

		// Already have a scheduler for this session so submit it

		scheduler->SubmitL(aEngine);

		}

	}

void CSsmSwpTransitionScheduler::Cancel(CSession2* aSession)

	{

	// Iterate through the array informing all schedulers of the cancel

	TInt count = iIndividualTransitionSchedulers.Count();

	for(TInt i = 0; i < count; ++i)

		{

		iIndividualTransitionSchedulers[i]->Cancel(aSession);

		}

	}

CSsmSwpIndividualTransitionScheduler* CSsmSwpTransitionScheduler::FindScheduler(CSsmSwpTransitionEngine* aEngine)

	{

	TInt offset = iIndividualTransitionSchedulers.FindInOrder(aEngine->TransitionValue().Key(), &SearchingFunction);

	if(offset != KErrNotFound)

		{

		return iIndividualTransitionSchedulers[offset];

		}

	return NULL;

	}

/**

Notify the monitor (if set) that one of the transition events has occured

*/

void CSsmSwpTransitionScheduler::NotifyTransitionQueued()

	{

	if(iTransactionMonitor != NULL)

		{

		iTransactionMonitor->SwpTransitionQueued();

		}

	}

void CSsmSwpTransitionScheduler::NotifyTransitionStarted()

	{

	if(iTransactionMonitor != NULL)

		{

		iTransactionMonitor->SwpTransitionStarted();

		}

	}

// Time to wait after completion before starting lazy cleanup

const TInt KLazyCleanupTimeOut = 5000000;

void CSsmSwpTransitionScheduler::NotifyTransitionCompleted()

	{

	DEBUGPRINT1(_L("ERequestSwpChange Completed"));

	if(iTransactionMonitor != NULL)

		{

		iTransactionMonitor->SwpTransitionCompleted(++iNumberOfCompletedTransitions);

		}

	if(!IsActive())

		{

		After(KLazyCleanupTimeOut);

		}

	}

void CSsmSwpTransitionScheduler::RunL()

	{

	// ignore any error in iStatus as clean-up is a safe operations to perform anytime

	// iterate through schedulers, removing them if they're not doing anything

	TInt top = iIndividualTransitionSchedulers.Count() - 1;

	for(TInt i = top; i >= 0; --i)

		{

		if (iIndividualTransitionSchedulers[i]->IsIdle())

			{

			delete iIndividualTransitionSchedulers[i];

			iIndividualTransitionSchedulers[i] = NULL;

			iIndividualTransitionSchedulers.Remove(i);

			}

		}

	// If there are now none left, free the memory

	if(iIndividualTransitionSchedulers.Count() == 0)

		{

		iIndividualTransitionSchedulers.GranularCompress();

		}

	}

TInt CSsmSwpTransitionScheduler::RunError(TInt __DEBUG_ONLY(aError))

	{

	DEBUGPRINT2A("CSsmSwpTransitionScheduler::RunError() run with error %d, ignoring", aError);

	// Ignore any errors with the timer as it is only used for clean up 

	return KErrNone;

	}

void CSsmSwpTransitionScheduler::NotifyTransitionFailed()

	{

	DEBUGPRINT1(_L("Error: ERequestSwpChange Failed"));

	if(iTransactionMonitor != NULL)

		{

		iTransactionMonitor->SwpTransitionFailed(++iNumberOfFailedTransitions);

		}

	}

/**

 * Used for testing purposes

 * Delete all the individual Transition Schedulers stored in the array

 * and free the memory

 */

#ifdef _DEBUG

void CSsmSwpTransitionScheduler::CleanupIndividualSchedulerArray()

	{

	TInt top = iIndividualTransitionSchedulers.Count() - 1;

	for(TInt i = top; i >= 0; --i)

		{

		if (iIndividualTransitionSchedulers[i]->IsIdle())

			{

			delete iIndividualTransitionSchedulers[i];

			iIndividualTransitionSchedulers[i] = NULL;

			iIndividualTransitionSchedulers.Remove(i);

			}

		}

	// If there are now none left, free the memory

	if(iIndividualTransitionSchedulers.Count() == 0)

		{

		iIndividualTransitionSchedulers.GranularCompress();

		}

	}

#endif