/*
* Copyright (c) 2004-2010 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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: 
* CSisRegistryCache - class used to store and access registry entry information in RAM 
* serving as a "cache" alternative to reading/seaching from other storage media
*
*/


/**
 @file 
 @released
 @internalComponent
*/
#ifndef __SISREGISTRYCACHE_H__
#define __SISREGISTRYCACHE_H__

#include <e32base.h>
#include <f32file.h>
#include <swi/swiobserverclient.h>
#include <s32strm.h>
#include <s32mem.h>
#include "sisregistrylog.h"


class RReadStream;
class RWriteStream;


namespace Swi
{
class CIntegrityServices;
class CSisRegistryPackage;
class CSisRegistryFile;
class CSisRegistryObject;
class CSisRegistryToken;
class CHashContainer;
class CSisRegistryFileDescription;
class TSisTrustStatus;

/**
 * @internalComponent
 * @released
 */

class CSisRegistryCache : public CBase
	{
public:
	static CSisRegistryCache* NewL();
	static CSisRegistryCache* NewLC();
	
	~CSisRegistryCache();
	
	/**
	 * Returns the current list of registered Uids, even those on removable media
	 */
	void UidListL(RArray<TUid>& aUids) const;

	/**
	 * Returns the current list of registered packages, even those on removable media
	 */
	void PackageListL(RPointerArray<CSisRegistryPackage>& aPackages) const;
	
    /**
     * Returns the current list of tokens.
     */	
	const RPointerArray<CSisRegistryToken>& TokenList() const;
	
	/**
	 * Returns the current list of registered packages, even those on removable media
	 */
	void PackageAugmentationsL(const TUid aUid, RPointerArray<CSisRegistryPackage>& aPackages) const;
	
	/**
	 * Returns the number of augmentations of a registred package with the passed UID
	 *
	 * @param aUid the UID of the package
	 * @return the augmentations number of the package
	 */
	TInt PackageAugmentationsNumber(const TUid aUid) const;
	
	/**
	 * Returns the Rfs handle, serves as a central point for all RFs calls
	 */
	RFs& RFsHandle();
	
	/**
	 * Returns a number between 1 and 0xFFFFFFFF, which internally identifies  
	 * a subsession and the assocaited registry entry 
	 */
    static TUint AllocateSubsessionId();
	
	/**
	 * Perform search of whether a specific object has been registered
	 */
	TBool IsRegistered(const TUid aUid) const;
	TBool IsRegistered(const CSisRegistryPackage& aPackage) const;
	TBool IsRegistered(const CHashContainer& aHashContainer) const;
	
	/**
	 * Perform search of whether a specific object (package, token) 
	 * has been registered conforming to specific search arguments. If found returns 
	 * reference to the object in question leave if not found, or if error
	 */
    CSisRegistryPackage& PackageL(const TUid aUid) const;
    CSisRegistryPackage& PackageL(const TUid aUid, TInt aIndex) const;
	CSisRegistryPackage& PackageL(const TDesC& aName, const TDesC& aVendor) const;
	CSisRegistryToken& TokenL(const TUid aUid, const TDesC& aName, const TDesC& aVendor) const;
	CSisRegistryToken& TokenL(const TUid aUid, TInt aIndex) const;
	
	/**
	 * create an object from registry file
	 */
	CSisRegistryObject* ObjectL(TUid aUid, const TDesC& aName, const TDesC& aVendor);
	CSisRegistryObject* ObjectL(TUid aUid, TInt aIndex);
	CSisRegistryObject* ObjectL(const CSisRegistryToken& aToken);
	
	CSisRegistryPackage& SidToPackageL(const TUid aSid) const;
	void SidToPackageL(const TUid aSid, RArray<CSisRegistryPackage>& aListMatchingPackages ) const;
	
	/**
	 * Find the given filename from the list of all tokens.
	 * Return whether file is modifiable.
	 */
	TBool ModifiableL(const TDesC& aFileName);
	
	/**
	 * Find the given filename from the list of all tokens.
	 * Return its hash.
	 */
	CHashContainer* HashL(const TDesC& aFileName);	

	void OpenReadHandleL(const CSisRegistryPackage& aPackage, TUint& aId);
    void CloseReadHandleL(TUint aId);
    
    CSisRegistryFile& HandleEntryL(TUint aId);
	CSisRegistryObject& EntryObjectL(TUint aId);
	
    
    void DependentsPackagesL(const CSisRegistryObject& aObject,
						 RPointerArray<CSisRegistryPackage>& aDependents);

	void EmbeddingPackagesL(const CSisRegistryObject& aObject,
						 RPointerArray<CSisRegistryPackage>& aEmbedding);
	
   	void GenerateChainListL(const CSisRegistryObject& aObject, 
   							RPointerArray<HBufC8>& aChainList);	
   							
	 /**
	 Loads a single controller belonging to the registry object and
	 places the controller buffer on the cleanup stack.
	 
	 @param aObject The SIS registry object that owns the controller
	 @param aIndex The index of the controller
	 @return a pointer to the buffer containing the controller.
	 */
	 HBufC8* LoadControllerLC(const CSisRegistryObject& aObject, TUint aIndex);   							

	void GenerateControllersArrayL(const CSisRegistryObject& aObject, 
									RPointerArray<HBufC8>& aControllers);	
	
	// drive oriented functionality											 
	void AddDriveAndRefreshL(TInt aDrive);
	void RemoveDriveAndRefresh(TInt aDrive);

	inline TUint FixedDrives() const;

	void RemoveRegistryEntryL(const CSisRegistryObject& aObject, CIntegrityServices& aIntegrityService);
	void RemoveRegistryFilesL(const CSisRegistryObject& aObject, CIntegrityServices& aIntegrityService);
	void AddRegistryEntryL(CSisRegistryObject& aObject, CIntegrityServices& aIntegrityService, const TDesC8& aController);

 	/// Regenerates the cache to match the files on disk
	// Existing integrity services journal files will be committed.
 	void RegenerateCacheL();

    /** 
     * Updates the trust status settings in the registry for the 
     * package identified by uid. Note that this updates the registry's 
     * file system.
     *
     * @param uid The uid of the registry entry to be updated
     * @param status The new trust status values to assign to the entry
     *
     * @return KErrNone on success
     * @return KErrInUse if another process holds the registry file requiring the update
     */
    TUint UpdateTrustStatusL(const TUid& uid,
                             const TSisTrustStatus& status );

	TBool IsSidPresent(const TUid aSid) const;
	
	/** 
     * Sets the remove with last dependent flag in the registry for the 
     * package identified by uid. Note that this updates the registry's 
     * file system.
     *
     * @param uid The uid of the registry entry to be updated
     * @param status The new trust status values to assign to the entry
     *
     * @return KErrNone on success
     * @return KErrInUse if another process holds the registry file requiring the update
     */
	TUint SetRemoveWithLastDependentL(const TUid& uid);
	
	/**
	 * Returns an array of the currently installed packages which can be removed
	 * (including augmentations).
	 *
	 * @param aPackages The array of installed packages which are removable
	 */
	void RemovablePackageListL(RPointerArray<CSisRegistryPackage>& aPackages);
	
	/**
	 * Performs a roll back and then regenerates the cache to match the registry files on disk
	 */
	void RecoverL();
	
private:	
	void ConstructL();

    /**
	 *  Used to locate the index of a registry file index in iFiles, which corresponds to 
	 *  aId argument value
	 */    	
	TInt FindReadHandleIndx(TUint aSubsessionId);	

    /**
	 * Used to cleanup the object as a part of a reset. 
	 */    		
    void CleanUp();
    	
	/**
	 * Builds the array of installed packages by scanning for UID directories
	 * within the SwiRegistry path.
	 *                                                   |-UID(hex)-|
	 * The path is in the form ...\sys\install\swiregistry\uuuuuuuu\
	 */
	void BuildUidListL();
	
	/**
	 * Builds the list with underlying files in a specific package directory
	 */
	void BuildFileListL(TUid aUid, const TDesC& aUidPath);
	
	void BuildRomListL();
	void RegisterInRomControllerL(const TDesC& aFileName);
	void DiscoverUidsL(TInt aDrive);
	void DiscoverStubsL(TInt aDrive);
	void RegisterControllerL(const TDesC& aFileName, CFileMan& aFileMan);
	void DiscoverControllersL(const TDesC& aRegistryPath, const TDesC& aDirectoryName);
	TBool IdentifyControllerL(TUid aUid, TInt aAugmentationIndex, const TDesC& aFileName);
	inline TBool UseIntegrityServices() const; // Integrity services is not needed during ROM stub processing

	/** 
	 * Cache internal state management
	 */
	 
	// check whether last time SisRegistryServer closed down correctly
	TBool BackupExists();
	
	// use backup file to initialise internal information;
	// files are committed at the end of the process 
	void InitFromBackupL();
	
	// used after a SisRegistryServer crashed / at first start up
	// files are committed at the end of the process 
	void InitStartUpL();
	
	// creates a copy of registry internal state in a file 
	void StoreBackupL();
    
    /**
	 * Drive management oriented
	 */    		
    void InitDrivesL();
    void UpdatePackagePresentStateL();
    
    // create an array of the drives used by a specific installed package 
	void ControllerDriveListL(const CSisRegistryObject& aObject, RArray<TInt>& aDriveList);
							  
	void AddEntryL(CSisRegistryObject& aObject, CIntegrityServices& aIntegrityService);				
	void RemoveEntryL(const CSisRegistryPackage& aPackage, CIntegrityServices& aIntegrityService);
	
 	void AddControllerL(const CSisRegistryObject& aObject, CIntegrityServices& aIntegrityService, const TDesC8& aBuffer, const TInt aDrive);
 	TBool RemoveControllerL(const CSisRegistryObject& aObject, CIntegrityServices& aIntegrityService, TInt aDrive);
 
 	void AddCleanupInfrastructureL(CSisRegistryObject& aObject, CIntegrityServices& aIntegrityServices, const TDesC8& aControllerBuffer);
 	void RemoveCleanupInfrastructureL(const CSisRegistryObject& aObject, CIntegrityServices& aIntegrityServices);

    /**
     * Persists the provided registry object into the specified file. Note all
     * other CSisRegistryFile objects refering to the specified file must have
     * their streams closed before calling this method.
     *
     * @param filename The file to write
     * @param obj The object to persist
     **/
    void UpdateRegistryFileL(const TFileName& filename,
                             const CSisRegistryObject& obj);

	void ReadSymbianHeaderL(RFile& aFile, TUid& aUid1, TUid& aUid2, TUid& aUid3);

	TUid IdentifyUidFromSisFileL(TDesC& aFilename);
	
	/**
	 * Resolves and sets the index value on embedded packages
	 */
	void ResolveEmbeddedPackage(CSisRegistryPackage* aPackage);
	 
	/**
	 * Updates the localizedvendorname and packagenames as per the current
	 * language of the device
	 */
	void UpdateLocalizedNamesL();
	 
	void CloseAllHandlesForUid(const TUid& aUId);
	 
	void ReloadAllHandlesForUidL(const TUid& aUId, const HBufC *registryFilename);	

	TBool IsFirmwareUpdatedL();
	 
	void  UpdateRecentFWVersionL(); 
		
private:
	// File system session which is used to make all requests to file server
	RFs iFs;
	
	// An array of 
	RPointerArray<CSisRegistryToken> iTokens;
	
	// Subsession id reference counter for currently open subsessions
	// it starts from 1 and increments with every subsession Open request
	// the counter rolls over when it reaches max value. It is assumed that 
	// this method reallistically would not suffer from id clash 
	static TUint iSubsessionId;	
	
	// files corresponding to subsessions
	// array of pointers to curenltly open registry objects 
	// the array index does not bear any relation to the id reference counter	
	RPointerArray<CSisRegistryFile> iFiles;

	// internal (sisregistryserver specific) object used to maintain the registry integrity 	
	CIntegrityServices* iIntegrityService;
	
	// Bitmap members which store currently present drives, one for all drives and one for 
	// permanent(fixed) drives.   
	TUint iPermDrives;  // stores just the fixed drives
	
	// Backup file
	HBufC* iBackupFile;
	
	// The registry is stored on the system drive
	TDriveNumber iSystemDrive;
	
	// ETrue if integrity services is needed for registry consistency
	TBool iUseIntegServices;
	
	//inner class of CSisRegistryCache
	class CSisLangChangeMonitor; 
	
	// Active Object used for language change monitoring.
	CSisLangChangeMonitor* iSisRegLangMonitor; 
	
	TBool isFwUpdated;
private:
	friend class CSisLangChangeMonitor;
	
public:
 	/**
 	 * Adds an entry to SWI Log for aObject.
 	 * 
 	 * @param aObject CSisRegistryObject 
     * @param Installinfo descriptor containing installation type
     */
    
  	void AddLogEntryL(const CSisRegistryObject& aObject, TSwiLogTypes aInstallinfo);

	};
	
inline TUint CSisRegistryCache::FixedDrives() const
	{
	return iPermDrives;
	}

inline TUint CSisRegistryCache::AllocateSubsessionId()
	{
	return (iSubsessionId < 0xFFFFFFFF)?(++iSubsessionId):(iSubsessionId = 1);	
	}
inline TBool CSisRegistryCache::UseIntegrityServices() const
	{
	return iUseIntegServices;
	}

} //namespace

#endif //__SISREGISTRYCACHE_H__