--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/sysstatemgmt/systemstatemgr/ssm/src/ssmswppolicyframe.cpp	Tue Feb 02 00:53:00 2010 +0200
@@ -0,0 +1,309 @@
+// 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 <e32cmn.h>
+
+#include <ssm/ssmswp.h>
+#include "ssmswppolicyframe.h"
+
+#include "ssmdebug.h"
+#include "ssmserverpanic.h"
+#include "ssmswppolicyproxy.h"
+
+
+/**
+signature of expected DLL factory function
+*/
+typedef MSsmSwpPolicy*(*TFuncSwpNewL)(void);
+
+/**
+Trivial constructor
+*/
+CSsmSwpPolicyFrame::CSsmSwpPolicyFrame()
+	{
+	}
+
+/**
+Static method to create a new frame and instantiate a policy using the
+supplied factory method
+
+@param aNewLFunc - a factory method that creates a new policy
+                   (the frame takes ownership)
+@return a new frame object that encapsulates a valid policy
+*/
+CSsmSwpPolicyFrame* CSsmSwpPolicyFrame::NewL(TLibraryFunction aNewLFunc)
+	{
+	CSsmSwpPolicyFrame* self = new (ELeave) CSsmSwpPolicyFrame();
+	CleanupStack::PushL (self);
+	self->ConstructL (aNewLFunc);
+	CleanupStack::Pop (self);
+	return self;
+	}
+
+/**
+Construct the frame and create the policy
+
+@param aNewLFunc - a factory method that creates a new policy
+@return a new frame object that encapsulates a valid policy
+*/
+void CSsmSwpPolicyFrame::ConstructL(TLibraryFunction aNewLFunc)
+	{
+	TFuncSwpNewL newL = reinterpret_cast<TFuncSwpNewL>( aNewLFunc );
+	iSwpPolicy = newL ();
+#ifdef _DEBUG
+	if(!iSwpPolicy)
+		{
+		DEBUGPRINT1(_L("First function in Swp Policy DLL didn't create a new instance"));
+		}
+#endif
+	SSMLOGLEAVEIFNULL(iSwpPolicy);
+	}
+
+/**
+Destroy the owned policy and release the library (if available).
+*/
+CSsmSwpPolicyFrame::~CSsmSwpPolicyFrame()
+	{
+	//Let the derived implementation handle its own destruction
+	if(iSwpPolicy)
+		{
+		iSwpPolicy->Release();
+		iSwpPolicy = NULL;
+		iLibrary.Close(); // release the dll
+		}
+	}
+
+/**
+Return the swp key that this frame is associated with
+
+@return this frame's swp value
+
+*/
+TUint CSsmSwpPolicyFrame::SwpKey() const
+	{
+	return iSwpKey;
+	}
+
+/**
+Set the swp key that this frame is associated with
+
+@param a valid swp key that matches the loaded policy
+
+*/
+void CSsmSwpPolicyFrame::SetSwpKey(TUint aKey)
+	{
+	iSwpKey = aKey;
+	}  //lint !e1746 Suppress parameter 'aKey' could be made const reference
+
+/**
+ Takes ownership of open handle
+ */
+void CSsmSwpPolicyFrame::SetLibrary(const RLibrary& aLibrary)
+	{
+	iLibrary = aLibrary;
+	}
+
+void CSsmSwpPolicyFrame::SetSsmSwpPolicySession(CSsmSwpPolicyCliSession* aSsmSwpPolicySession)
+	{
+	iSsmSwpPolicySession = aSsmSwpPolicySession;
+	}
+
+/**
+Accessor to the policy's asynchronous Initialize method
+
+@param aStatus to inform the caller of completion.
+Note: the possible values for the completion status are defined by the policy method
+
+*/
+void CSsmSwpPolicyFrame::CallInitialize(TRequestStatus& aStatus)
+	{
+	__ASSERT_DEBUG(NULL != iSwpPolicy, PanicNow(KPanicSysStateMgr,ESwpPolicyFrameError1));
+	__ASSERT_DEBUG(NULL != iSsmSwpPolicySession, PanicNow(KPanicSysStateMgr,ESwpPolicyFrameError18));
+
+	// lazy initialisation
+	// if initialization is already called then we are simply completing the request with KErrNone.
+	if (!iInitializeCalled)
+		{
+		iSsmSwpPolicySession->CallSetDllHandleAndInitialize(iLibrary.Handle(), aStatus);
+		iInitializeCalled = ETrue;
+		iInternalState = EWaitForPrepare;
+		}
+	else // complete
+		{
+		DEBUGPRINT1(_L("SwpPolicy is already initialized"));
+		TRequestStatus* status = &aStatus;
+		User::RequestComplete (status, KErrNone);
+		}
+	}
+
+/**
+Accessor to the policy's synchronous Cancel method
+
+*/
+TInt CSsmSwpPolicyFrame::CallInitializeCancel()
+	{
+	__ASSERT_DEBUG(NULL != iSwpPolicy, PanicNow(KPanicSysStateMgr,ESwpPolicyFrameError15));
+	__ASSERT_DEBUG(NULL != iSsmSwpPolicySession, PanicNow(KPanicSysStateMgr,ESwpPolicyFrameError22));
+
+	TInt err = KErrNone;
+	if (iInitializeCalled)
+		{
+		err = iSsmSwpPolicySession->CallInitializeCancel();
+		iInternalState = EWaitForPrepare;
+		}
+	return err;
+	}
+
+/**
+Accessor to the policy's synchronous TransitionAllowed method
+
+@param aSwp swp value to interrogate
+@param aMessage Contains information about the requesting client process.
+@return the response to the query
+*/
+MSsmSwpPolicy::TResponse CSsmSwpPolicyFrame::CallTransitionAllowed(const TSsmSwp& aSwp, const RMessagePtr2& aMessage)
+	{
+	// CallTransitionAllowed can be called at any time as long as the object has been initialised
+	__ASSERT_DEBUG(NULL != iSwpPolicy, PanicNow(KPanicSysStateMgr,ESwpPolicyFrameError3));
+	__ASSERT_DEBUG(iInitializeCalled, PanicNow(KPanicSysStateMgr,ESwpPolicyFrameError4));
+
+	MSsmSwpPolicy::TResponse response = MSsmSwpPolicy::ENotAllowed;
+
+	// Since this is a synchronous call we are not using iSsmSwpPolicySession
+	// for enquiring about response returned from TransitionAllowed.
+	if (iInitializeCalled)
+		{
+		response = iSwpPolicy->TransitionAllowed(aSwp, aMessage);
+		}
+	return response;
+	}
+
+/**
+Accessor to the policy's asynchronous PrepareCommandList method
+
+@param aSwp swp value to interrogate
+@param aStatus to inform the caller of completion
+Note: the possible values for the completion status are defined by the policy method
+
+*/
+void CSsmSwpPolicyFrame::CallPrepareCommandList(const TSsmSwp& aSwp, TRequestStatus& aStatus)
+	{
+	__ASSERT_DEBUG(EWaitForPrepare == iInternalState || EWaitForCommandListExecution == iInternalState, PanicNow(KPanicSysStateMgr,ESwpPolicyFrameError5));
+	__ASSERT_DEBUG(aSwp.Key() == iSwpKey, PanicNow(KPanicSysStateMgr,ESwpPolicyFrameError6));
+
+	__ASSERT_DEBUG(NULL != iSwpPolicy, PanicNow(KPanicSysStateMgr,ESwpPolicyFrameError7));
+	__ASSERT_DEBUG(NULL != iSsmSwpPolicySession, PanicNow(KPanicSysStateMgr,ESwpPolicyFrameError19));
+	__ASSERT_DEBUG(iInitializeCalled, PanicNow(KPanicSysStateMgr,ESwpPolicyFrameError8));
+
+	// if initialization is not called then we are simply completing the request with KErrNone.
+	if (iInitializeCalled)
+		{
+		iSsmSwpPolicySession->CallPrepareCommandList(aSwp, aStatus);
+		iInternalState = EWaitForGet;
+		}
+	else // complete
+		{
+		DEBUGPRINT1(_L("SwpPolicy is not initialized"));
+		TRequestStatus* status = &aStatus;
+		User::RequestComplete (status, KErrNone);
+		}
+
+	} //lint !e1746 Suppress parameter 'aSwp' could be made const reference
+
+/**
+Accessor to the policy's synchronous Cancel method
+
+*/
+TInt CSsmSwpPolicyFrame::CallPrepareCommandListCancel()
+	{
+	__ASSERT_DEBUG(NULL != iSwpPolicy, PanicNow(KPanicSysStateMgr,ESwpPolicyFrameError16));
+	__ASSERT_DEBUG(NULL != iSsmSwpPolicySession, PanicNow(KPanicSysStateMgr,ESwpPolicyFrameError23));
+
+	TInt err = KErrNone;
+	// iSsmSwpPolicySession is the session with ssmswppolicycli
+	if (iInitializeCalled)
+		{
+		err = iSsmSwpPolicySession->CallPrepareCommandListCancel();
+		iInternalState = EWaitForPrepare;
+		}
+	return err;
+	}
+
+/**
+Accessor to the policy's synchronous CommandList method
+
+@return a valid command list for execution or NULL
+
+*/
+CSsmCommandList* CSsmSwpPolicyFrame::CallCommandList()
+	{
+	__ASSERT_DEBUG(EWaitForGet == iInternalState, PanicNow(KPanicSysStateMgr,ESwpPolicyFrameError9));
+	__ASSERT_DEBUG(NULL != iSwpPolicy, PanicNow(KPanicSysStateMgr,ESwpPolicyFrameError10));
+	__ASSERT_DEBUG(NULL != iSsmSwpPolicySession, PanicNow(KPanicSysStateMgr,ESwpPolicyFrameError20));
+	__ASSERT_DEBUG(iInitializeCalled, PanicNow(KPanicSysStateMgr,ESwpPolicyFrameError11));
+
+	CSsmCommandList* list=  NULL;
+	if (iInitializeCalled)
+		{
+		list = iSsmSwpPolicySession->CallCommandList();
+		iInternalState = EWaitForCommandListExecution;
+		}
+	return list;
+	}
+
+/**
+Accessor to the policy's asynchronous HandleCleReturnValue method
+
+@param TInt the value returned by the CLE
+@param aStatus to inform the caller of completion
+Note: the possible values for the completion status are defined by the policy method
+
+*/
+void CSsmSwpPolicyFrame::CallHandleCleReturnValue(const TSsmSwp& aSwp, TInt aError, TInt aSeverity, TRequestStatus& aStatus)
+	{
+	__ASSERT_DEBUG(EWaitForCommandListExecution == iInternalState, PanicNow(KPanicSysStateMgr,ESwpPolicyFrameError12));
+	__ASSERT_DEBUG(NULL != iSwpPolicy, PanicNow(KPanicSysStateMgr,ESwpPolicyFrameError13));
+	__ASSERT_DEBUG(NULL != iSsmSwpPolicySession, PanicNow(KPanicSysStateMgr,ESwpPolicyFrameError21));
+	__ASSERT_DEBUG(iInitializeCalled, PanicNow(KPanicSysStateMgr,ESwpPolicyFrameError14));
+
+	// If initialization is not called then we are simply completing the request with KErrNone.
+	if (iInitializeCalled)
+		{
+		iSsmSwpPolicySession->CallHandleCleReturnValue(aSwp, aError, aSeverity, aStatus);
+		iInternalState = EWaitForPrepare;
+		}
+	else // complete
+		{
+		DEBUGPRINT1(_L("SwpPolicy is not initialized"));
+		TRequestStatus* status = &aStatus;
+		User::RequestComplete(status, KErrNone);
+		}
+	}
+
+/**
+Accessor to the policy's synchronous Cancel method
+
+*/
+TInt CSsmSwpPolicyFrame::CallHandleCleReturnValueCancel()
+	{
+	__ASSERT_DEBUG(EWaitForPrepare == iInternalState, PanicNow(KPanicSysStateMgr,ESwpPolicyFrameError17));
+	__ASSERT_DEBUG(NULL != iSwpPolicy, PanicNow(KPanicSysStateMgr,ESwpPolicyFrameError2));
+	__ASSERT_DEBUG(NULL != iSsmSwpPolicySession, PanicNow(KPanicSysStateMgr,ESwpPolicyFrameError24));
+	__ASSERT_DEBUG(iInitializeCalled, PanicNow(KPanicSysStateMgr,ESwpPolicyFrameError14));
+
+	TInt err = iSsmSwpPolicySession->CallHandleCleReturnValueCancel();
+	iInternalState = EWaitForPrepare;
+	return err;
+	}