// 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 "ssmserverpanic.h"

#include "ssmswprequesthandler.h"

#include "ssmswptransitionscheduler.h"

#include "ssmswptransitionengine.h"

#include "ssmswppolicyresolverproxy.h"

#include "ssmswppolicyframe.h"

//

// Creation and Construction methods

//

/**

@leave 	One of the system-wide error codes.

@return A newly created CSsmSwpRequestHandler

*/

CSsmSwpRequestHandler* CSsmSwpRequestHandler::NewL( )

	{

	CSsmSwpRequestHandler* self = NewLC ( );

	CleanupStack::Pop (self );

	return self;

	}

/**

@leave One of the system-wide error codes.

@return A newly created CSsmSwpRequestHandler on the cleanup stack

*/

CSsmSwpRequestHandler* CSsmSwpRequestHandler::NewLC( )

	{

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

	CleanupStack::PushL (self );

	self->ConstructL ( );

	return self;

	}

/**

Empty constructor

*/

CSsmSwpRequestHandler::CSsmSwpRequestHandler() : iPerformCommandListValidation(ETrue)

	{

	}

/**

 Construct transition scheduler

 @leave	One of the system-wide error codes.

 */

void CSsmSwpRequestHandler::ConstructL( )

	{

	iSwpTransitionScheduler = CSsmSwpTransitionScheduler::NewL ( );

	}

/**

Empty destructor

*/

CSsmSwpRequestHandler::~CSsmSwpRequestHandler( )

	{

	delete iSwpTransitionScheduler;

	}

//

// Public API methods

//

void CSsmSwpRequestHandler::SetSwpHandlerMonitor(MSwpHandlerMonitor* aMonitor)

	{

	iSwpHandlerMonitor = aMonitor;

	}

void CSsmSwpRequestHandler::SetSwpPolicyResolverProxy(MSsmSwpPolicyResolverProxy* aPolicyResolverProxy)

	{

	iSwpPolicyResolverProxy = aPolicyResolverProxy;

	}

void CSsmSwpRequestHandler::SetCleSessionProxy(MCleSessionProxy* aCleSessionProxy)

	{

	iCleSessionProxy = aCleSessionProxy;

	}

void CSsmSwpRequestHandler::PerformCommandListValidation(TBool aSetting)

	{

	iPerformCommandListValidation = aSetting;

#ifdef _DEBUG

	if(iPerformCommandListValidation)

		{

		DEBUGPRINT1(_L("Turning on State command list validation"));

		}

	else

		{

		DEBUGPRINT1(_L("Turning off State command list validation"));

		}

#endif

	}

/**

Receives a swp request and handles it synchronously

@param aRequest An swp change request

@leave One of the system-wide error codes.

*/

void CSsmSwpRequestHandler::SubmitRequestL(const TSsmSwp& aRequest )

	{

	__ASSERT_DEBUG(NULL != iSwpTransitionScheduler, PanicNow(KPanicSysStateMgr,ESwpRequestHandlerError1));

	DoSubmitRequestL (aRequest, NULL );

	}

/**

Receives a swp request and handles it asynchronously

@param aRequest An swp change request

@param aMessage Client message  to complete

@leave One of the system-wide error codes.

*/

void CSsmSwpRequestHandler::SubmitRequestL(const TSsmSwp& aRequest,

		const RMessage2& aMessage )

	{

	__ASSERT_DEBUG(NULL != iSwpTransitionScheduler, PanicNow(KPanicSysStateMgr,ESwpRequestHandlerError2));

	DoSubmitRequestL (aRequest, &aMessage );

	}

/**

 Cancel all running and queued requests

 */

void CSsmSwpRequestHandler::Cancel(CSession2* aSession)

	{

	__ASSERT_DEBUG(NULL != iSwpTransitionScheduler, PanicNow(KPanicSysStateMgr,ESwpRequestHandlerError3));

	iSwpTransitionScheduler->Cancel(aSession);

	}

//

// Private methods

//

/**

Resolve the policy for the swp value

Set up the engine ready for running

Add the engine to the scheduler

@param aRequest An swp change request

@leave KErrNotFound If swp value is not registered

@leave Or one of the system-wide error codes

*/

void CSsmSwpRequestHandler::DoSubmitRequestL(const TSsmSwp& aRequest, const RMessage2* aMessage)

	{

	__ASSERT_DEBUG(NULL != iSwpPolicyResolverProxy, PanicNow(KPanicSysStateMgr,ESwpRequestHandlerError4));

	__ASSERT_DEBUG(NULL != iCleSessionProxy, PanicNow(KPanicSysStateMgr,ESwpRequestHandlerError5));

	NotifyRequestMade (aRequest );

	// get the policy

	CSsmSwpPolicyFrame* policyFrame = iSwpPolicyResolverProxy->GetSwpPolicyL(aRequest);

	SSMLOGLEAVEIFNULL(policyFrame);

	CleanupStack::PushL(policyFrame);

	// Create an engine

	CSsmSwpTransitionEngine* engine = CSsmSwpTransitionEngine::NewL (aRequest);

	engine->SetCleSessionProxy(iCleSessionProxy);

	engine->SetSwpPolicyFrame(policyFrame); // and take ownership

	CleanupStack::Pop (policyFrame ); // engine takes ownership

	CleanupStack::PushL (engine);

	engine->PerformCommandListValidation(iPerformCommandListValidation);

	iSwpTransitionScheduler->SubmitL (engine ); // scheduler takes ownership

	CleanupStack::Pop (engine );

	engine->SetClientMessage (aMessage ); // client wants to be notified

	}

//

//Event notification interface

//

/**

Flag request made

@param aRequest Value of swp request

*/

void CSsmSwpRequestHandler::NotifyRequestMade(const TSsmSwp& aRequest )

	{

	if (NULL != iSwpHandlerMonitor )

		{

		iSwpHandlerMonitor->SwpRequestMade (aRequest );

		}

	}

/**

 * Used only for testing purposes

 * Cleans up the Transition Scheduler

 */

#ifdef _DEBUG

void CSsmSwpRequestHandler::CleanupSwpTransitionScheduler()

	{

	iSwpTransitionScheduler->CleanupIndividualSchedulerArray();

	}

#endif