diff -r 000000000000 -r 08ec8eefde2f persistentstorage/centralrepository/cenrepsrv/shrepos.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/persistentstorage/centralrepository/cenrepsrv/shrepos.h Fri Jan 22 11:06:30 2010 +0200 @@ -0,0 +1,284 @@ +// Copyright (c) 2004-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: +// + +#ifndef SHREPOS_H +#define SHREPOS_H + +#include +#include "obsrvr_noc.h" +#include "srvres.h" +#include "srvdefs.h" +#include "setting.h" +#include "clientrequest.h" +#include "panic.h" +#include "transstate.h" +#include "inifile.h" +#include "rstrepos.h" +#include "datatype.h" +#include "heaprepos.h" + +class CRepositoryTransactor; + +class CSharedRepository : public CBase + { + friend class CObservable; + friend class CServerRepository; + friend class TConvToolTester; + +public: + static CSharedRepository* NewL(TUid aUid); + ~CSharedRepository(); + + TUid Uid() const; + + TInt CommitChanges(TCentRepLocation aLocation = EPersists); + void CommitChangesL(TCentRepLocation aLocation = EPersists) + { + User::LeaveIfError(CommitChanges(aLocation)); + } + + void CreateL(TServerSetting& s, TSettingsAccessPolicy* &aPolicy, TBool aFirstLoad, TBool aSingleMetaFound=EFalse); + + void SetMetaDataOnRead(TServerSetting& aSetting, TBool aSingleMetaFound); + + void SetMetaDataOnCreate(TServerSetting& aNewSetting, TUint32* aMeta); + + TInt DeleteAndPersist(TUint32 aId); + TInt DeleteNoPersist(TUint32 aId); + + TInt ResetNoPersistL(TServerSetting& aSetting); + void ResetAndPersistL(TServerSetting& aSetting); + TInt ResetAllNoPersistL(CSharedRepository& aRepository); + + const TSecurityPolicy& GetFallbackReadAccessPolicy(TUint32 aId); + inline const TSecurityPolicy& GetReadAccessPolicy(const TServerSetting& aSetting); + inline const TSecurityPolicy& GetReadAccessPolicy(TUint32 aId); + inline const TSecurityPolicy& GetDefaultReadAccessPolicy(); + + const TSecurityPolicy& GetFallbackWriteAccessPolicy(TUint32 aId); + inline const TSecurityPolicy& GetWriteAccessPolicy(const TServerSetting& aSetting); + inline const TSecurityPolicy& GetWriteAccessPolicy(TUint32 aId); + inline const TSecurityPolicy& GetDefaultWriteAccessPolicy(); + + TSettingsAccessPolicy* GetFallbackAccessPolicy(TUint32 aId +#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS + ,TBool aSkipSingle=EFalse +#endif + ); + + TInt StartTransaction(CRepositoryTransactor& aTransactor, TInt aMode); + TInt CommitTransaction(CRepositoryTransactor& aTransactor, TUint32& aKeyInfo); + void CancelTransaction(CRepositoryTransactor& aTransactor); + TInt FailTransaction(CRepositoryTransactor& aTransactor, TInt aError, TUint32 aErrorKey); + void FailAllTransactions(const CRepositoryTransactor* aExcludeTransactor); + TInt AttemptPromoteTransactionToReadWrite(CRepositoryTransactor& aTransactor); + TBool IsTransactionActive(); + + void MergeL(CSharedRepository& aInstallRep, TMergeType aMergeType); +#ifndef SYMBIAN_CENTREP_SUPPORT_MULTIROFS + TInt FindLocationForFileL(TCentRepLocation& aLocation,TUid aUid,const TCentRepFileType aType) const; +#endif + + void HandleUpdateMergeL(TTime aInstallFileTimeStamp, CSharedRepository& aInstallRep); + void HandleDeleteMergeL(CSharedRepository& aRomRep); + void SetInstallTime(TTime aInstallTime); + + inline TUid Owner() {return iSimRep->Owner(); } + inline void WriteBackupStream(RWriteStream& aStream) const; + inline void WriteDeletedSettingsStream(RWriteStream& aStream) const; + inline void InternalizeL(RReadStream& aStream, CRestoredRepository& aRstRepos) ; + void ExternalizeCre(RWriteStream& aStream) const; + void InternalizeCreL(RReadStream& aStream) ; +#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS + void InternalizeCreL(RReadStream& aStream,TUint8& aCreVersion); +#endif + TInt ReloadContentL(CIniFileIn& aIniFile, TBool aFirstLoad = EFalse); +#ifdef CENTREP_CONV_TOOL + void DoCommitChangesToIniFileL(const TDesC& aOutFileName +#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS + ,TUint32 aCreVersion +#endif + ); +#endif + inline void SetSize(TInt aSize); + inline TInt Size() const; + +private: + + void ResetContent(); + void RestoreConsistencyL(); + void DoRestoreConsistencyL(); + TInt CreateRepositoryFromCreFileL(TCentRepLocation aLocation); + TInt ReadSettingSavePolicyL(CIniFileIn& aFile,TServerSetting& aSetting, TSettingsAccessPolicy* &aPolicy, TBool& aSingleMetaFound); + void ReleaseTransactionLock(CRepositoryTransactor& aTransactor); + TInt DoCommitTransactionSettings(CRepositoryTransactor& aTransactor, TUint32& aKeyInfo); + void Notify(TUint32 aVal) const; + + RSettingsArray& GetSettings(); + CSharedRepository(); + void ConstructL(TUid aUid); + +#ifdef FOTA_UNIT_TESTING +public: + void SetUid(TUid aUid) + { + iSimRep->SetUid(aUid); + } +#endif + CHeapRepository* iSimRep; + + TInt32 iSize; //approximate size(in memory) of the repository after internalisation + TBool iNotificationState;//Notification can be made if iNotificationState is non-zero, + //otherwise the notification is disabled + + //iInconsistentData data flag will be set at the beginning of CommitChangesL() + //and reset at the end of it. The flag is used to implement lazy-load approach for the + //repository - if CommitChangesL() fails, the in-memory representation of the repository + //won't match the updated by CommitChangesL() repository (ini) file. The repository + //consistency has to be restored before any next call of CSharedRepository methods. + TBool iInconsistentData; + }; + +/** +@internalTechnology +Base class for CServerRepository and other objects that may be in transactions with the +shared repository. Contains a double queue link so the shared repository can build a queue +of them. In order to use transactions in the shared repository, the object needs to supply a +CRepositoryTransactor - either itself or a member variable. This makes it possible to +prevent one transactor from closing another's transaction. +Stores transaction state and changes made during the transaction. +Also stores RMessage2 while pending async start or commit, and handles its completion. +*/ +class CRepositoryTransactor : public CBase + { + // shared repository may set private transaction state, but not derived classes + friend class CSharedRepository; + // for the _FOFF macro to work + friend class CObservable::TSharedRepositoryInfo; + friend class CObservable; +public: + + inline TInt TransactionState() const + { + return iTransactionState; + } + inline TInt TransactionMode() const + { + return iTransactionState & EAllTransactionModeBits; + } + inline TBool IsInTransaction() const + { + return iTransactionState != ENoTransaction; + } + inline TBool IsInActiveTransaction() const + { + // transaction is active if no bits apart from the (non-zero) mode are set + return (iTransactionState != ENoTransaction) && (TransactionMode() == iTransactionState); + } + inline TBool IsInActiveReadTransaction() const + { + return iTransactionState == EReadTransaction; + } + inline TBool IsInActiveConcurrentReadWriteTransaction() const + { + return (iTransactionState == EConcurrentReadWriteTransaction); + } + inline TBool IsInActiveExclusiveReadWriteTransaction() const + { + return (iTransactionState == EReadWriteTransaction); + } + inline TBool IsInActiveReadWriteTransaction() const + { + return (iTransactionState == EReadWriteTransaction) + || (iTransactionState == EConcurrentReadWriteTransaction); + } + inline TBool IsInFailedTransaction() const + { + return (iTransactionState & EFailedBit) != 0; + } + +protected: + inline void ClearSettings() + { + iTransactionSettings.Reset(); + } + +private: + inline void SetFailed(TInt aError, TUint32 aErrorKey) + { + // don't want to fail more than once + ASSERT(IsInActiveTransaction()); + ASSERT(aError != KErrNone); // must fail for a reason + iTransactionState |= EFailedBit; + ClearSettings(); + iTransactionResult = aError; + iTransactionErrorKey = aErrorKey; + } + inline void PromoteToExclusiveReadWrite() + { + ASSERT(iTransactionState == EReadTransaction); + iTransactionState = EReadWriteTransaction; + ClearSettings(); + } + inline void AddToQueue(TSglQue& aTransactors, TInt aMode) + { + ASSERT(!IsInTransaction()); + // if the following ASSERT fails, transactor is already in a queue + ASSERT(iLink.iNext == NULL); + aTransactors.AddLast(*this); + iTransactionState = aMode; + // check adding to queue in an active state + ASSERT(IsInActiveTransaction()); + ClearSettings(); + // clear failure reasons + iTransactionResult = KErrNone; + iTransactionErrorKey = KUnspecifiedKey; + } + inline void Deque() + { + iTransactionState = ENoTransaction; + ClearSettings(); + delete iIniRep; + iIniRep = NULL; + } + +protected: + // derived classes are free to change transaction settings. + // these can be made persistent by committing write transaction + RSettingsArray iTransactionSettings; + + // 'Create' needs to check the default (INI) file to see if the + // key position has a setting defined. If that is the case, + // the new setting uses meta defined for the original setting + // in the INI file. + // Store data read from INI here so that we only read the INI + // once per transaction. + CSharedRepository* iIniRep; + +private: + // A queue link used by the CSharedRepository the CTransactor is working on + TSglQueLink iLink; + // integer encoding transaction state using definition of TTransactionState + TInt iTransactionState; + // result to be returned by commit if transaction failed earlier + TInt iTransactionResult; + // if transaction failed earlier, key or partial key involved in the original error, + // or KUnspecifiedKey if could not be attributed to just one. + TUint32 iTransactionErrorKey; + }; + +#include "shrepos.inl" + +#endif // SHREPOS_H