diff -r 000000000000 -r 4e1aa6a622a0 sysstatemgmt/systemstatemgr/ssm/src/ssmswppolicyframe.cpp --- /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 + +#include +#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( 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; + }