diff -r 000000000000 -r 4e1aa6a622a0 sysstatemgmt/systemstatemgr/cmd/src/cmdcreateswp.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/sysstatemgmt/systemstatemgr/cmd/src/cmdcreateswp.cpp Tue Feb 02 00:53:00 2010 +0200 @@ -0,0 +1,368 @@ +// 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 +#include +#include + +#include "cmdcreateswp.h" +#include "ssmdebug.h" +#include "ssmpanic.h" +#include "ssmcommandparameters.h" + +/** +Used to create an instance of CCmdCreateSwp class from a read stream. +CSsmCommandList::InternalizeL() uses this method to construct a command from stream. + +@param aReadStream Read stream containing data through which object can be created +@return A pointer to an object of type CCmdCreateSwp. +*/ +CCmdCreateSwp* CCmdCreateSwp::NewL(RReadStream& aReadStream) + { + CCmdCreateSwp* self = new (ELeave) CCmdCreateSwp(); + CleanupStack::PushL(self); + self->ConstructL(aReadStream); + CleanupStack::Pop(self); + return self; + } + +#ifdef SYMBIAN_SSM_FLEXIBLE_MERGE +/** +Used to create an instance of CCmdCreateSwp class from given parameters. +This method is used by SsmCommandFactory to create a command. + +@param aSeverity The severity of the command +@param aSwpInfo The system wide property info +@param aFilename The policy file to associate it to +@param aPriority The priority of the command in the list +@return A pointer to an object of type CCmdCreateSwp. +*/ +CCmdCreateSwp* CCmdCreateSwp::NewL(TCmdErrorSeverity aSeverity, const TSsmSwp& aSwpInfo, const TDesC& aFilename, const TUint16 aPriority) + { + CCmdCreateSwp* self = new (ELeave) CCmdCreateSwp(aSeverity, aSwpInfo, aPriority); + CleanupStack::PushL(self); + self->ConstructL(aFilename); + CleanupStack::Pop(self); + return self; + } +#endif + +/** +Used to create an instance of CCmdCreateSwp class from given parameters. +This method is used by SsmCommandFactory to create a command. + +@param aSeverity The severity of the command +@param aSwpInfo The system wide property info +@param aFilename The policy file to associate it to +@return A pointer to an object of type CCmdCreateSwp. +*/ +CCmdCreateSwp* CCmdCreateSwp::NewL(TCmdErrorSeverity aSeverity, const TSsmSwp& aSwpInfo, const TDesC& aFilename) + { + CCmdCreateSwp* self = new (ELeave) CCmdCreateSwp(aSeverity, aSwpInfo); + CleanupStack::PushL(self); + self->ConstructL(aFilename); + CleanupStack::Pop(self); + return self; + } + +/** +Used to create an instance of CCmdCreateSwp class from resource. + +@param aCommandParameters Object data from a resource file +@return A pointer to an object of type CCmdCreateSwp. +*/ +CCmdCreateSwp* CCmdCreateSwp::NewL(TSsmCommandParameters& aCommandParameters) + { + CCmdCreateSwp* self = new (ELeave) CCmdCreateSwp(); + CleanupStack::PushL(self); + self->ConstructL(aCommandParameters); + CleanupStack::Pop(self); + return self; + } + +/** +Used to create an instance of CCmdCreateSwp class from CCmdCreateSwp object +Must be used only by CLE +@param aCmdCreateSwp CCmdCreateSwp reference +@return A pointer to an object of type CCmdCreateSwp. +*/ +CCmdCreateSwp* CCmdCreateSwp::NewLC(const CCmdCreateSwp& aCmdCreateSwp) + { +#ifdef SYMBIAN_SSM_FLEXIBLE_MERGE + CCmdCreateSwp* self = new (ELeave) CCmdCreateSwp(aCmdCreateSwp.Severity(),aCmdCreateSwp.SsmSwpInfo(), + aCmdCreateSwp.Priority()); +#else + CCmdCreateSwp* self = new (ELeave) CCmdCreateSwp(aCmdCreateSwp.Severity(),aCmdCreateSwp.SsmSwpInfo()); +#endif + CleanupStack::PushL(self); + self->ConstructL(aCmdCreateSwp); + return self; + } + +void CCmdCreateSwp::ConstructL(const CCmdCreateSwp& aCmdCreateSwp) + { + iConditionalResourceId = aCmdCreateSwp.ConditionalInformation(); + iFileName.CreateL(aCmdCreateSwp.FileName()); +#ifdef SYMBIAN_SSM_FLEXIBLE_MERGE + if (iConditionalResourceId != 0) + { + SetCommandResourceFileNameL(aCmdCreateSwp.GetCommandResourceFileName()); + } +#endif + } + +/** +Destructor +*/ +CCmdCreateSwp::~CCmdCreateSwp() + { + Cancel(); + iSsm.Close(); + iFileName.Close(); + } + +/** +Initialises the BIC's active object and initiates the command + +@param aStatus The TRequestStatus of the active object calling this BIC +*/ +void CCmdCreateSwp::Execute(TRequestStatus& aStatus) + { + aStatus = KRequestPending; + iExecuteRequest = &aStatus; + + CompleteRequest(iStatus, iSsm.Connect()); + SetActive(); + } + +/** +Releases resources associated with this BIC +*/ +void CCmdCreateSwp::Release() + { + delete this; + } + +/** +Initiates a Cancel on the object. +*/ +void CCmdCreateSwp::ExecuteCancel() + { + //cancel the outstanding request + Cancel(); + //and complete the request with KErrCancel + CompleteExecuteRequest(KErrCancel); + } + +/** +Returns the type of the BIC + +@return The type of the BIC +*/ +TSsmCommandType CCmdCreateSwp::Type() const + { + return (ESsmCmdCreateSwp); + } + +/** +Returns the Version of the BIC + +@return The maximum supported version of the BIC +*/ +TInt CCmdCreateSwp::MaxSupportedVersion() + { +#ifdef SYMBIAN_SSM_FLEXIBLE_MERGE + return (static_cast(ECmdCreateSwpVersionWithPriority)); +#else + return (static_cast(ECmdCreateSwpInitialVersion)); +#endif + } + +/** +Configures the BIC using data contained in a ReadStream + +@param aReadStream A read stream containing BIC data +*/ +void CCmdCreateSwp::InternalizeL(RReadStream& aReadStream) + { + iSeverity = static_cast(aReadStream.ReadInt16L()); + const TUint key = aReadStream.ReadUint32L(); + const TInt value = aReadStream.ReadInt32L(); + TSsmSwp swpInfo(key, value); + iSwpInfo = swpInfo; + HBufC* filename = HBufC::NewL(aReadStream, KMaxFileName); + CleanupStack::PushL(filename); + ConstructL(*filename); + CleanupStack::PopAndDestroy(filename); +#ifdef SYMBIAN_SSM_FLEXIBLE_MERGE + iPriority = aReadStream.ReadUint16L(); +#endif + } + +/** +Externalises the configuration of the BIC + +@param aWriteStream A write stream to write BIC data to +*/ +void CCmdCreateSwp::ExternalizeL(RWriteStream& aWriteStream) const + { + aWriteStream.WriteInt16L(iSeverity); + aWriteStream.WriteUint32L(iSwpInfo.Key()); + aWriteStream.WriteInt32L(iSwpInfo.Value()); + aWriteStream << iFileName; +#ifdef SYMBIAN_SSM_FLEXIBLE_MERGE + aWriteStream.WriteUint16L(iPriority); +#endif + } + +/** +Completes the tasks of the BIC +*/ +void CCmdCreateSwp::RunL() + { + SSMLOGLEAVEIFERROR(iStatus.Int()); + + TUid category = RProcess().SecureId(); + _LIT_SECURITY_POLICY_PASS(KReadPolicy); + _LIT_SECURITY_POLICY_S0(KWritePolicy, RProcess().SecureId()); + TInt err = RProperty::Define(category, iSwpInfo.Key(), RProperty::EInt, KReadPolicy, KWritePolicy); + if (KErrNone != err && KErrAlreadyExists != err) + { + SSMLOGLEAVE(err); + } + SSMLOGLEAVEIFERROR(RProperty::Set(category, iSwpInfo.Key(), iSwpInfo.Value())); + SSMLOGLEAVEIFERROR(iSsm.RegisterSwpMapping(iSwpInfo.Key(), iFileName)); + CompleteExecuteRequest(KErrNone); //control reaching here implies there are no errors + } + +/** +Called to handle any cleanup if RunL leaves + +@param aError The error to finish with +@return KErrNone +*/ +TInt CCmdCreateSwp::RunError(TInt aError) + { + CompleteExecuteRequest(aError); + return KErrNone; + } + +/** +Called during cancellation of the active BIC +*/ +void CCmdCreateSwp::DoCancel() + { + } + +/** +Default constructor. +*/ +CCmdCreateSwp::CCmdCreateSwp() + : iSwpInfo(0, 0) + { + } + +#ifdef SYMBIAN_SSM_FLEXIBLE_MERGE +/** +Overloaded constructor + +@param aSeverity The severity of the command +@param aSwpInfo The system wide property info +@param aPriority The priority of the command in the list +*/ +CCmdCreateSwp::CCmdCreateSwp(TCmdErrorSeverity aSeverity, const TSsmSwp& aSwpInfo, const TUint16 aPriority) + : CSsmCommandBase(aSeverity, aPriority), iSwpInfo(aSwpInfo) + { + } +#endif + +/** +Overloaded constructor + +@param aSeverity The severity of the command +@param aSwpInfo The system wide property info +*/ +CCmdCreateSwp::CCmdCreateSwp(TCmdErrorSeverity aSeverity, const TSsmSwp& aSwpInfo) + : CSsmCommandBase(aSeverity), iSwpInfo(aSwpInfo) + { + } + +/** +Constructs the object through read stream. + +@param aFileName Name of the dll implementing the MSsmSwpPolicy interface. +*/ +void CCmdCreateSwp::ConstructL(const TDesC& aFileName) + { + iFileName.CreateL(aFileName.Length()); + iFileName.Append(aFileName); + + ValidateL(); + } + +/** +Constructs the object through read stream and validates the data. + +@param aReadStream A read stream containing BIC data +*/ +void CCmdCreateSwp::ConstructL(RReadStream& aReadStream) + { + InternalizeL(aReadStream); + ValidateL(); + } + +/** +Validate the commands data +@leave KErrArgument If file name is not valid +*/ +void CCmdCreateSwp::ValidateL() + { + RFs fs; + SSMLOGLEAVEIFERROR(fs.Connect()); + TBool isValidFileName = fs.IsValidName(iFileName); + fs.Close(); + if (!isValidFileName) + { + SSMLOGLEAVE(KErrArgument); + } + } + +/** +Constructs an object from resource file and validates the data.. + +@param aCommandParameters Object data from a resource file +*/ +void CCmdCreateSwp::ConstructL(TSsmCommandParameters& aCommandParameters) + { + RResourceReader& reader = aCommandParameters.MainReader(); + + const TSsmCommandType type = static_cast(reader.ReadInt16L()); + SSMLOGLEAVEIFFALSE(type == Type(), KErrNotSupported); + const TInt version = reader.ReadInt16L(); + SSMLOGLEAVEIFFALSE(__COMPARE_VERSION(version, CCmdCreateSwp::MaxSupportedVersion()), KErrNotSupported); + iSeverity = static_cast(reader.ReadInt16L()); + const TUint key = {reader.ReadUint32L()}; + const TInt32 value = reader.ReadInt32L(); + const TSsmSwp swpInfo(key, value); + iSwpInfo = swpInfo; + const TPtrC fileName = reader.ReadTPtrCL(); + ConstructL(fileName); +#ifdef SYMBIAN_SSM_FLEXIBLE_MERGE + iPriority = (version > ECmdCreateSwpInitialVersion) ? reader.ReadUint16L() : KDefaultCommandPriority; +#endif + } +