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

//

#include <ssm/ssmstates.hrh>

#include <ssm/ssmstatetransition.h>

#include <ssm/ssmstatepolicy.h>

#include <ssm/ssmuiproviderdll.h>

#include "ssmserverpanic.h"

#include "ssmserver.h"

#include "ssmsession.h"

#include "ssmclisrv.h"

#include "clesessionproxy.h"

#include "ssmstatepolicyresolver.h"

#include "ssmstatetransitionengine.h"

#include "ssmstatepolicyresolverproxy.h"

#include "ssmstatetransitionrequest.h"

#include "ssmstatepolicyframe.h"

#include "ssmswppolicyresolver.h"

#include "ssmswprequesthandler.h"

#include "ssmdebug.h"

// ------------------- Policy Server Security Setup ----------------------

const TUint  KRangeCount = 3;

const TInt   KRanges[KRangeCount] =

	{

	0,						// op-code 0 not used

	KSsmFirstUsedOpCode,	//range: KFirstUsedSsmOpCode...(EEndOfSsmOpCodes-1) inclusive

	EEndOfSsmOpCodes

	};

/**

 Specifies the appropriate action for each range in KRanges.

 The nth element of KElementsIndex specifies the appropriate action for the nth range in KRanges.

 */

const TUint8 KElementsIndex[KRangeCount] =

	{

	CPolicyServer::ENotSupported,

	CPolicyServer::EAlwaysPass,	//All request will be accepted and passed on to policy DLL for security checks

	CPolicyServer::ENotSupported,

	};

/**

 Setup a security policy that always allows connection requests for all requests.

 */

const CPolicyServer::TPolicy KSsmServerPolicy =

	{

	CPolicyServer::EAlwaysPass,	// Always allow connection requests

	KRangeCount,

	KRanges,

	KElementsIndex,

	NULL

	};

// ------------------- SsmServer Implementation ----------------------

/**

 EPriorityHigh to make sure the server is always scheduled before other AO such

 as CSsmStateTransitionEngine.

 */

CSsmServer::CSsmServer() : CPolicyServer(EPriorityHigh, KSsmServerPolicy)

	{

	}

/**

 */

CSsmServer::~CSsmServer()

	{

	const TInt ignore = User::SetCritical(User::ENotCritical);

	delete iStateTransitionEngine;

	delete iSwpRequestHandler;

	delete iSwpResolver;

	if(NULL != iSwpCleSession)

		{

		iSwpCleSession->ReleaseCle();

		}

	if(iSsmUiSpecific)

        {

        iSsmUiSpecific->Release();

        }

	} //lint !e529 not subsequently referenced

/**

 */

CSsmServer* CSsmServer::NewLC()

	{

	return CSsmServer::NewLC(ESsmStartup, EDoValidateCommandLists);

	}

/**

 */

CSsmServer* CSsmServer::NewLC(TUint16 aInitialState)

	{

	return CSsmServer::NewLC(aInitialState, EDoValidateCommandLists);

	}

/**

 */

CSsmServer* CSsmServer::NewLC(TUint16 aInitialState, TValidation aSetting)

	{

	CSsmServer* server = new(ELeave) CSsmServer();

	CleanupStack::PushL(server);

	server->ConstructL(aInitialState, aSetting);

	server->StartL(KSsmServerName);

	return server;

	}

#ifdef TEST_SSM_SERVER

/**

 Factory method used by automated tests to avoid clash with production server name.

 */

CSsmServer* CSsmServer::NewLC(const TDesC& aServerName, TUint16 aInitialState)

	{

	CSsmServer* server = new(ELeave) CSsmServer();

	CleanupStack::PushL(server);

	server->ConstructL(aInitialState, ENoCommandListValidation);

	server->StartL(aServerName);

	return server;

	}

#endif //TEST_SSM_SERVER

/**

 */

void CSsmServer::ConstructL(TUint16 aInitialState, TValidation aSetting)

	{

	__ASSERT_ALWAYS( KErrNone == User::SetCritical(User::ESystemCritical), PanicNow(KPanicSysStateMgr,ESsmServerError1));

	__ASSERT_ALWAYS( KErrNone == User::RenameThread(KSsmServerName), PanicNow(KPanicSysStateMgr,ESsmServerError2));

	iSsmUiSpecific = CSsmUiSpecific::InstanceL();

	//Reserve memory for critical operation especially when phone memory will be full

    TInt err = iSsmUiSpecific->ReservePhoneMemorySpace();

	DEBUGPRINT2(_L("CSsmUiSpecific::ReservePhoneMemorySpace returned with = %d"), err);

	// --- Instantiate the "System State" handling classes ---

	// Create a state policy resolver and load the initial policy

	CSsmStatePolicyResolver* stateResolver = CSsmStatePolicyResolver::NewLC();

	const TSsmState initalState = TSsmState(aInitialState, KSsmAnySubState);

	stateResolver->GetStatePolicyL(initalState);

	CCleSessionProxy* stateCleSession = CCleSessionProxy::NewL();

	CleanupStack::PushL(stateCleSession);

	// Create the state transition engine and let it take ownership of stateResolver and stateCleSession

	iStateTransitionEngine = CSsmStateTransitionEngine::NewL(stateResolver, stateCleSession);

	CleanupStack::Pop(2, stateResolver);

	// Configure engine

	iStateTransitionEngine->PerformCommandListValidation(EDoValidateCommandLists==aSetting);

	// --- Instantiate the SWP handling classes ---

	iSwpResolver = CSsmSwpPolicyResolver::NewL();

	iSwpCleSession = CCleSessionProxy::NewL(); // Thought: Perhaps the CleSessionProxy should be a CLE session factory, thus allowing a separate session to be created for each engine

	// Create the swp request handler and wire it up to the proxies

	iSwpRequestHandler = CSsmSwpRequestHandler::NewL();

	iSwpRequestHandler->SetSwpPolicyResolverProxy(iSwpResolver);

	iSwpRequestHandler->SetCleSessionProxy(iSwpCleSession);

	iSwpRequestHandler->PerformCommandListValidation(EDoValidateCommandLists==aSetting);

	//Request initial actions

	const TSsmStateTransition doStartup(initalState, 0);

	iStateTransitionEngine->SubmitL(doStartup);

	}

/**

 */

CSession2* CSsmServer::NewSessionL(const TVersion& aVersion, const RMessage2& /*aMessage*/) const

	{

	// Check we're the right version

	TVersion version(KSsmServMajorVersionNumber,KSsmServMinorVersionNumber,KSsmServBuildVersionNumber);

	if (!User::QueryVersionSupported(version,aVersion))

		{

		User::Leave(KErrNotSupported);

		}

	// version supported, go ahead

	return CSsmSession::NewL();

	}

/**

 */

void CSsmServer::RequestStateTransitionL(const TSsmState& aState, TInt aReason, const RMessage2& aMessage)

	{

	__ASSERT_DEBUG(iStateTransitionEngine, PanicNow(KPanicSysStateMgr,ESsmServerError3));

	const TSsmStateTransition request(aState, aReason);

	const MSsmStatePolicy::TResponse response = iStateTransitionEngine->TransitionAllowed(request, aMessage);

	switch(response)

		{

		case MSsmStatePolicy::EDefinitelyAllowed:

		case MSsmStatePolicy::ECurrentRemainReplaceQueued:

			{

			// A leave here will complete the client-request with KErrNoMemory

			iStateTransitionEngine->SubmitL(request, aMessage);

			break;

			}

		case MSsmStatePolicy::EReplaceCurrentClearQueue:

			{

			iStateTransitionEngine->Cancel(NULL);

			iStateTransitionEngine->SubmitL(request, aMessage);

			break;

			}

		case MSsmStatePolicy::ENotAllowed:

		default:

			{

			aMessage.Complete(KErrNotSupported);

			break;

			}

		}

	}

/**

 Cancel any transition job that is accepted but not yet started.

 */

void CSsmServer::RequestStateTransitionCancel(CSession2* aSession)

	{

	iStateTransitionEngine->Cancel(aSession);

	}

/**

 Initiate processing of the request for a system wide property change

 */

void CSsmServer::RequestSwpChangeL(const TSsmSwp& aSwp, const RMessage2& aMessage)

	{

	iSwpRequestHandler->SubmitRequestL(aSwp, aMessage);

	}

/**

 Cancel processing of pending and running system wide property change requests

 */

void CSsmServer::RequestSwpChangeCancel(CSession2* aSession)

	{

	iSwpRequestHandler->Cancel(aSession);

	}

/**

 Register the policy file name for this swp

 This also marks the actual existence of the swp

 */

void CSsmServer::RequestRegisterSwpMappingL(TUint aSwpKey, const TDesC& aFilename)

	{

	iSwpResolver->RegisterSwpMappingL(aSwpKey, aFilename);

	}  //lint !e1746 Suppress parameter 'aSwpKey' could be made const reference

/**

 * Used only for testing purposes

 * DeRegister the policy file name for this swp

 */

#ifdef _DEBUG

void CSsmServer::RequestDeRegisterSwpMappingL(TUint aSwpKey, const TDesC& aFilename)

	{

	iSwpResolver->DeRegisterSwpMappingL(aSwpKey, aFilename);

	}

#endif

/**

 * Used only for testing purposes

 * Cleanup Transition Engine after the test is over

 */

#ifdef _DEBUG

void CSsmServer::DoCleanupStateTransitionEngine()

	{

	iStateTransitionEngine->CleanupTransitionEngine();

	}

#endif

/**

 * Used only for testing purposes

 * Cleanup Request Handler after the test is over

 */

#ifdef _DEBUG

void CSsmServer::DoCleanupSwpRequestHandler()

	{

	iSwpRequestHandler->CleanupSwpTransitionScheduler();

	}

#endif