// Copyright (c) 2008-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 <ssm/ssmcommandlist.h>

#include "ssmdebug.h"

#include "ssmserverpanic.h"

#include "ssmswppolicyframe.h"

#include "ssmswptransitionengine.h"

#include "ssmswppolicyframe.h"

#include "clesessionproxy.h"

#include "ssmcommandlistutils.h"

//

//Construction/Destruction

//

/**

Create an engine using the swp value supplied

@param aSwp Associated swp value

@return A new instance of CSsmSwpTransitionEngine

*/

CSsmSwpTransitionEngine* CSsmSwpTransitionEngine::NewL(const TSsmSwp& aSwp)

	{

	CSsmSwpTransitionEngine* self = new (ELeave) CSsmSwpTransitionEngine(aSwp);

	CleanupStack::PushL (self);

	self->ConstructL ();

	CleanupStack::Pop (self);

	return self;

	}

/**

Empty Construct

*/

void CSsmSwpTransitionEngine::ConstructL()

	{

	}

/**

Construct engine

@param aSwp Associated swp value

*/

CSsmSwpTransitionEngine::CSsmSwpTransitionEngine(const TSsmSwp& aSwp) :

	CActive(CActive::EPriorityStandard), iClientStatus(NULL),

			iCurrentSwpValue(aSwp), iNextAction(EIdle), iPerformCommandListValidation(ETrue)

	{

	CActiveScheduler::Add (this);

	}

/**

Destruct engine and destroy owned frame

*/

CSsmSwpTransitionEngine::~CSsmSwpTransitionEngine()

	{

	__ASSERT_DEBUG(KNullHandle == iClientMessage.Handle(), PanicNow(KPanicSysStateMgr,ESwpTransitionEngineError18));

	Cancel();

	delete iPolicyFrame; // owned by me

    delete iCommandList;

    }

/**

Give the engine a client message

If a client message is supplied, it will be completed when the engine starts running

or if an error occurs

@param aMessage Client message

*/

void CSsmSwpTransitionEngine::SetClientMessage(const RMessage2* aMessage)

	{

	if(aMessage)

		{

		iClientMessage = *aMessage;

		}

	}

CSession2* CSsmSwpTransitionEngine::OriginatingSesssion() const

	{

	return iClientMessage.Session();

	}

void CSsmSwpTransitionEngine::PerformCommandListValidation(TBool aSetting)

	{

	iPerformCommandListValidation = aSetting;

	}

/**

Give the engine a cle session

@param aCleSession Object that implements CLE Session proxy interface

*/

void CSsmSwpTransitionEngine::SetCleSessionProxy(MCleSessionProxy* aCleSession)

	{

	__ASSERT_DEBUG(NULL != aCleSession, PanicNow(KPanicSysStateMgr,ESwpTransitionEngineError1));

	iCleSession = aCleSession;

	}

/**

Give the engine a ssmSwpPolicy session

@param aSsmSwpPolicySession Object that has RSsmSwpPolicySession Session

*/

void CSsmSwpTransitionEngine::SetSsmSwpPolicySession(CSsmSwpPolicyCliSession* aSsmSwpPolicySession)

	{

	__ASSERT_DEBUG(NULL != aSsmSwpPolicySession, PanicNow(KPanicSysStateMgr,ESwpTransitionEngineError21));

	iSsmSwpPolicySession = aSsmSwpPolicySession;

	}

/**

Give the engine a policy frame

Note: the engine takes ownership of the frame

@param aPolicyFrame Policy frame

*/

void CSsmSwpTransitionEngine::SetSwpPolicyFrame(CSsmSwpPolicyFrame* aPolicyFrame)

	{

	__ASSERT_DEBUG(NULL != aPolicyFrame, PanicNow(KPanicSysStateMgr,ESwpTransitionEngineError2));

	iPolicyFrame = aPolicyFrame;

	}

#ifdef TEST_SSM_SERVER

/**

Start a transition without completion notification

This method is for testcode only

*/

void CSsmSwpTransitionEngine::Submit()

	{

	__ASSERT_DEBUG(!IsActive(), PanicNow(KPanicSysStateMgr,ESwpTransitionEngineError3));

	__ASSERT_DEBUG(iClientStatus == NULL, PanicNow(KPanicSysStateMgr,ESwpTransitionEngineError5));

	iClientStatus=NULL;

	DoSubmit ();

	}

#endif

/**

Start a transition with completion notification

@param aClientStatus - the client status to complete

*/

void CSsmSwpTransitionEngine::Submit(TRequestStatus& aClientStatus)

	{

	__ASSERT_ALWAYS(!IsActive(), PanicNow(KPanicSysStateMgr,ESwpTransitionEngineError4));

	__ASSERT_ALWAYS(iClientStatus == NULL, PanicNow(KPanicSysStateMgr,ESwpTransitionEngineError5));

	aClientStatus = KRequestPending;

	iClientStatus = &aClientStatus;

	DoSubmit ();

	}

/**

Start transition engine running

*/

void CSsmSwpTransitionEngine::DoSubmit()

	{

	// Submit can only be called on a brand new engine

	__ASSERT_DEBUG(EIdle == iNextAction, PanicNow(KPanicSysStateMgr,ESwpTransitionEngineError6));

	__ASSERT_ALWAYS(NULL != iCleSession, PanicNow(KPanicSysStateMgr,ESwpTransitionEngineError14));

	__ASSERT_ALWAYS(NULL != iPolicyFrame, PanicNow(KPanicSysStateMgr,ESwpTransitionEngineError15));

	__ASSERT_ALWAYS(NULL != iSsmSwpPolicySession, PanicNow(KPanicSysStateMgr,ESwpTransitionEngineError23));

	TInt err = KErrNone;

	// Before this transition engine can be used, we need to connect to (and probably start) the Ssmswppolicysrv.

	// The session remains connected as long as SsmSwpPolicySrv does not disconnect itself (due to a panic for example)

	if (!iSsmSwpPolicySession->IsConnected())

		{

		TRAP(err, iSsmSwpPolicySession->ConnectL());

		DEBUGPRINT2(_L("CSsmSwpTransitionEngine iSsmSwpPolicySession->ConnectL called with err: %d"), err);

		}

	if (err != KErrNone)

		{

		// Call DoRunError() to handle the error.

		DoRunError(err);

		}

	else

		{

		// Sets the SsmSwpPolicySession in the policyframe

		iPolicyFrame->SetSsmSwpPolicySession(iSsmSwpPolicySession);

		iNextAction = iCleSession->IsConnected() ? ESetSwpPolicyDllHandleAndInitialize : EUnConnected;

		Start ();

		}

	}

/**

Start active scheduler running it's state machine

*/

void CSsmSwpTransitionEngine::Start()

	{

	SetActive ();

	TRequestStatus* status = &iStatus;

	User::RequestComplete (status, KErrNone);

	}

/**

Cancel the running of the engine

Cancel any running command lists

Complete the client request if supplied

*/

void CSsmSwpTransitionEngine::DoCancel()

	{

	__ASSERT_DEBUG(iPolicyFrame, PanicNow(KPanicSysStateMgr,ESwpTransitionEngineError7));

	TInt err = KErrCancel;

	//Cancel any request this engine is waiting for

	if( iNextAction == EIdle)

		{

		__ASSERT_DEBUG(iClientStatus==NULL, PanicNow(KPanicSysStateMgr,ESwpTransitionEngineError17));

		return;

		}

	else if( iPolicyFrame && (iNextAction == ETransitionAllowed) )

		{

		err = iPolicyFrame->CallInitializeCancel();

		}

	else if( iPolicyFrame && (iNextAction == EExecuteCommandList) )

		{

		err = iPolicyFrame->CallPrepareCommandListCancel();

		}

	else if( iCleSession && (iNextAction == EWaitForCommandListExecute) )

		{

		iCleSession->ExecuteCommandListCancel();

		}

	else if( iPolicyFrame && (iNextAction == EWaitForHandleCleReturnValue) )

		{

		err = iPolicyFrame->CallHandleCleReturnValueCancel();

		//iCommandList needs to be deleted when cancel has been called before completion of command 

        if (iCommandList)

            {

            delete iCommandList;

            iCommandList = NULL;

            }

		}

	//Then complete the transition-scheduler's TRequestStatus

	if( NULL != iClientStatus )

		{

		User::RequestComplete (iClientStatus, err);

		iClientStatus = NULL;

		}

	//And let the end-user know

	CompleteClientMessage (err);

	iNextAction = EIdle;

	}

/**

The engine runs through a fixed sequence of steps, most of which require an asynchronous reply from

another component in the system

@leave One of the system-wide error codes

*/

void CSsmSwpTransitionEngine::RunL()

	{

	if(iNextAction != EWaitForCommandListExecute)

		{

		//Propagate all problems except CleSrv's return code to RunError

		SSMLOGLEAVEIFERROR(iStatus.Int()); //will leave in release builds as well

		}

	switch (iNextAction)

		{

		case EUnConnected:

			DoConnectCleSessionL();

			iNextAction = ESetSwpPolicyDllHandleAndInitialize;

			break;

		case ESetSwpPolicyDllHandleAndInitialize:

			DoInitialize();

			iNextAction = ETransitionAllowed;

			break;

		case ETransitionAllowed:

			iNextAction = DoTransitionAllowed() ? EPrepareCommandList : EIdle;

			break;

		case EPrepareCommandList:

			DoPrepareCommandList();

			iNextAction = EExecuteCommandList;

			break;

		case EExecuteCommandList:

			DoExecuteCommandList();

			iNextAction = EWaitForCommandListExecute;

			break;

		case EWaitForCommandListExecute:

            if (iCommandList)

                {

                delete iCommandList;

                iCommandList = NULL;

                }

			DoHandleCleReturnValue();

			iNextAction = EWaitForHandleCleReturnValue;

			break;

		case EWaitForHandleCleReturnValue:

			if(NULL != iClientStatus)

				{

				User::RequestComplete(iClientStatus, KErrNone);

				iClientStatus = NULL;

				}

			iNextAction = ETransitionComplete;

			break;

		case EIdle:

		default:

			__ASSERT_DEBUG(EFalse, PanicNow(KPanicSysStateMgr,ESwpTransitionEngineError19));

			break;

		}

	}

TBool CSsmSwpTransitionEngine::InTransition() const

	{

	return (iNextAction > ETransitionAllowed);

	}

/**

 * Returns the current SwP value for this transition engine.

 */

const TSsmSwp& CSsmSwpTransitionEngine::TransitionValue() const

	{

	return iCurrentSwpValue;

	}

/**

 * Returns the MCleSessionProxy currently associated with this engine

 */

MCleSessionProxy* CSsmSwpTransitionEngine::CleSessionProxy()

	{

	return iCleSession;

	}

/**

 Most errors cause a Panic followed by Kernel fault. The rationale behind this is that all

 swp policies placed on the rom by the device manufacturer must be free from errors when

 a device is shipped. There is no case for graceful handling of missing commandlists,

 bad resource files or an unknown swp.

 In case there is low memory condition then we are completing the client request status with KErrNoMemory,

 instead of panicking the client.

 Note: Both the return value from CleSrv (which is forwarded to the Swp Policy DLL) and the error resulting

 	   from a transition not allowed do NOT cause this RunError() to be called.

*/

TInt CSsmSwpTransitionEngine::RunError(TInt aError)

	{

	DoRunError(aError);

	return KErrNone;

	}

void CSsmSwpTransitionEngine::DoRunError(TInt aError)

	{

	if(NULL != iClientStatus && aError == KErrNoMemory)

		{

		User::RequestComplete(iClientStatus, aError);

		iClientStatus = NULL;

		//And let the end-user know

		CompleteClientMessage (aError);

		}

	else

		{

		DEBUGPRINT3(_L("CSsmSwpTransitionEngine RunError called with aError: %d when iNextAction had the value of: %d"), aError, iNextAction);

		PanicNow(KPanicSysStateMgr,ESwpTransitionEngineError20);

		}

	}

/**

 Before this transition engine can be used, we need to connect to (and probably start) the CleSrv.

 The session remains connected as long as Cle does not disconnect itself (due to a panic for example)

 */

void CSsmSwpTransitionEngine::DoConnectCleSessionL()

	{

	iCleSession->ConnectL();

	Start();

	}

/**

Call the policy's Initialize method

Wait asynchronously for completion

*/

void CSsmSwpTransitionEngine::DoInitialize()

	{

	__ASSERT_DEBUG(iPolicyFrame, PanicNow(KPanicSysStateMgr,ESwpTransitionEngineError8));

	//Let the swp policy do whatever it needs to do e.g. initialize its CSsmCommandListResourceReader

	iPolicyFrame->CallInitialize (iStatus);

	SetActive ();

	}

/**

Call the policy's TransitionAllowed method and handle return value appropriately

Continue with sequence if allowed

Complete message and request with correct status if not allowed

*/

TBool CSsmSwpTransitionEngine::DoTransitionAllowed()

	{

	__ASSERT_DEBUG(iPolicyFrame, PanicNow(KPanicSysStateMgr,ESwpTransitionEngineError9));

	MSsmSwpPolicy::TResponse response = iPolicyFrame->CallTransitionAllowed(iCurrentSwpValue, iClientMessage);

	if( MSsmSwpPolicy::EAllowed == response) // continue as normal

		{

		CompleteClientMessage(KErrNone);	// tell the caller we were accepted

		Start();

		return ETrue;

		}

	else // complete with error status

		{

		CompleteClientMessage (KErrNotSupported); // tell the caller we were rejected

		if ( NULL != iClientStatus)

			{

			User::RequestComplete (iClientStatus, KErrNotSupported);

			iClientStatus = NULL;

			}

		return EFalse;

		}

	}

/**

Call the policy's PrepareCommandList method and wait for completion

*/

void CSsmSwpTransitionEngine::DoPrepareCommandList()

	{

	__ASSERT_DEBUG(iPolicyFrame, PanicNow(KPanicSysStateMgr,ESwpTransitionEngineError10));

	iPolicyFrame->CallPrepareCommandList (iCurrentSwpValue, iStatus);

	SetActive ();

	}

/**

Retrieve the prepared command list

Request execution of the command list

Wait asynchronously for execution to complete

@leave KErrNoMemory if the list is NULL

*/

void CSsmSwpTransitionEngine::DoExecuteCommandList()

	{

	__ASSERT_DEBUG(iPolicyFrame, PanicNow(KPanicSysStateMgr,ESwpTransitionEngineError11));

	__ASSERT_DEBUG(iCleSession, PanicNow(KPanicSysStateMgr,ESwpTransitionEngineError13));

	iCommandList = iPolicyFrame->CallCommandList();

	if(iPerformCommandListValidation)

		{

		DoValidation();

		}

	if(iCommandList)

		{

		iCleSession->ExecuteCommandList(*iCommandList, iStatus, iSeverity);

		SetActive ();

		}

	else

		{

		Start();

		}

	}

void CSsmSwpTransitionEngine::DoValidation()

	{

	TBool valid = EFalse;

	if(!iCommandList)

		{

		DEBUGPRINT1(_L ("System-Wide-Property DLL's CommandList() function returned NULL"));

		}

	else

		{

		valid = CSsmCommandListUtils::IsValidSwpList(*iCommandList);

		if(!valid)

			{

			DEBUGPRINT1(_L("System-Wide-Property DLL's CommandList() function returned an invalid CommandList()"));

			}

		}

	__ASSERT_ALWAYS( iCommandList && valid, PanicNow(KPanicSysStateMgr,ESwpTransitionEngineError16));

	}

/**

Pass the request status returned by the CLE to the policy

Wait asynchronously for the policy to complete the handling

*/

void CSsmSwpTransitionEngine::DoHandleCleReturnValue()

	{

	__ASSERT_DEBUG(iPolicyFrame, PanicNow(KPanicSysStateMgr,ESwpTransitionEngineError12));

	const TInt error = iStatus.Int ();

	// In case the server is no longer present

	if(error == KErrServerTerminated)

		{

		// Close cle handle and mark it as disconnected

		iCleSession->Close();

		}

	// Severity must be obtained from CLE somehow. This needs proper implementation.

	TCmdErrorSeverity severity = ECmdIgnoreFailure;

	if(KErrNone != error)

		{

		DEBUGPRINT3(_L("Commandlist execution reported error: %d, with severity %d."), error, severity);

		severity = ECmdCriticalSeverity;

		}

	iPolicyFrame->CallHandleCleReturnValue(iCurrentSwpValue, error, severity, iStatus);

	SetActive ();

	}