// Copyright (c) 1997-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:

// Implements installed file notification

// 

//

/**

 @internalComponent

*/

#include "install.h"

#include "srvrepos.h"

#include "srvres.h"

#include "srvparams.h"

#include "cachemgr.h"

CCentRepSWIWatcher* CCentRepSWIWatcher::NewL(RFs& aFs)

	{

	CCentRepSWIWatcher* self = new(ELeave) CCentRepSWIWatcher(aFs);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CCentRepSWIWatcher::ConstructL()

	{

	// Attach to SWI property

	User::LeaveIfError(iSWIKey.Attach( KUidSystemCategory, KUidSoftwareInstallKey));

	// Initialise SWI operation and status

	TInt swiProperty;

	const TInt error = iSWIKey.Get(KUidSystemCategory, KUidSoftwareInstallKey, swiProperty);

	if (error == KErrNone)

		{

		iSWIOperation=swiProperty & KSwisOperationMask;

		iSWIStatus= swiProperty & KSwisOperationStatusMask;

		}

	else if (error != KErrNotFound)

		{

		User::LeaveIfError(error);

		}

	// Get last saved contents of install directory

	GetInstallDirL();

	// Do any actions required by pre server start-up SWI activity

	TRAP_IGNORE(FindChangedEntriesL(ETrue));

	}

CCentRepSWIWatcher::CCentRepSWIWatcher(RFs& aFs) :

 	CActive(EPriorityStandard), 

 	iInstallDir(*TServerResources::iInstallDirectory),

 	iFs(aFs),

 	iSWIOperation( ESwisNone),

	iSWIStatus( ESwisStatusSuccess)

	{

 	CActiveScheduler::Add(this);

	}

CCentRepSWIWatcher::~CCentRepSWIWatcher()

	{

	Cancel();

	iSWIKey.Cancel();

	iSWIKey.Close();

	iInstallEntryArray.ResetAndDestroy();

	iCurrentInstallDirEntries.ResetAndDestroy();

	}

void CCentRepSWIWatcher::Start()

	{

	if(IsActive())

		return;

	NotifyChange();

	}

 void CCentRepSWIWatcher::NotifyChange()

 	{

	// Register for P&S of SWI flag

	iSWIKey.Subscribe(iStatus);

	SetActive();

	}

void CCentRepSWIWatcher::RunL()

	{	

	// Get SWI Key 

	TInt swiProperty;

	User::LeaveIfError(iSWIKey.Get(KUidSystemCategory, KUidSoftwareInstallKey, swiProperty));

	HandleSWIEventL(swiProperty);

	NotifyChange();

	}

void CCentRepSWIWatcher::HandleSWIEventL(TInt aSWIProperty)

	{	

	iSWIOperation=aSWIProperty & KSwisOperationMask;

	iSWIStatus=   aSWIProperty & KSwisOperationStatusMask;

	// Need to handle successful and aborted install/uninstall and successful restore

	// Can't handle aborted restore

	switch(iSWIOperation)

		{

		case ESwisNone:

			break;

		case ESwisInstall:

		case ESwisUninstall:

			if(iSWIStatus==ESwisStatusSuccess)

				{

				// Handle SWI events

				FindChangedEntriesL();

				}

			else if(iSWIStatus==ESwisStatusAborted)

				{

				// Update directory to reset timestamps

				ReadInstallDirL(iInstallEntryArray);

				SaveInstallDirL();

				}

			break;

		case ESwisRestore:

			break;

		default:

			break;

		}

	}

// Catch leaves so they don't stop the server

TInt CCentRepSWIWatcher::RunError( TInt aError)

	{

	static_cast<void>(aError);

	RDebug::Print(_L("Run error %d"), aError);

	// Reinitialise directory list

	iInstallEntryArray.ResetAndDestroy();

	if(!IsActive())

		{

		NotifyChange();

		}

	return KErrNone;

	}

void CCentRepSWIWatcher::DoCancel()

	{

	// Cancel subscription to SW P&S flag

	iSWIKey.Cancel();

	iSWIKey.Close();

	}

void CCentRepSWIWatcher::ReadInstallDirL(RPointerArray<CInstallEntry> &aEntryArray)

	{

	CDir* installDir=NULL;

	//Empty contents of directory

	aEntryArray.ResetAndDestroy();

	// Read contents of install directory

	User::LeaveIfError(iFs.GetDir(iInstallDir,KEntryAttNormal, ESortByDate, installDir));

	CleanupStack::PushL(installDir);

	const TInt fileCount = installDir->Count();

	TInt i = 0;

	for(;i<fileCount; ++i)

		{

		CInstallEntry* installEntry = CInstallEntry::NewL();

		CleanupStack::PushL(installEntry);

		TEntry entry=(*installDir)[i];

		installEntry->SetL(entry);

		User::LeaveIfError(aEntryArray.Append(installEntry));

		CleanupStack::Pop(installEntry);

		}

	CleanupStack::PopAndDestroy(installDir);

	}

TBool CCentRepSWIWatcher::MatchEntries( const CInstallEntry &aSource, const CInstallEntry &aTarget)

	{

	return((aSource.Uid()==aTarget.Uid()) &&

	       (aSource.FileExt()==aTarget.FileExt()));

	}

void CCentRepSWIWatcher::FindChangedEntriesL(TBool aStartup)

	{

	// Find added or updated entries

	ReadInstallDirL(iCurrentInstallDirEntries);

	TInt newCount=iCurrentInstallDirEntries.Count();

	TInt currentCount=iInstallEntryArray.Count();

	TInt i;

	TInt r;

	TInt operation;

	// If both counts are 0, we shouldn't have been notified, just return

	if( (newCount==0) && (currentCount==0))

		return;

	if(aStartup)

		{

		operation=ESwisNone;

		}

	else

		{

		operation=iSWIOperation;

		}

	if( newCount==0)						// currentCount > 0, newCount = 0

		{									// All installed files have been deleted

		// Handle deletes of all files

		for(i=0;i<currentCount;i++)

			{

			iInstallEntryArray[i]->HandleFileDeleteL(operation);

			}

		// Free memory of elements

		iInstallEntryArray.ResetAndDestroy();

		}

	else 

		{	

		if( currentCount==0)				// currentCount = 0, newCount > 0

			{								// All new files need to be handled

			for(i=0;i<newCount;i++)

				{

				CInstallEntry* newEntry=iCurrentInstallDirEntries[i];

				newEntry->HandleFileCreateL(operation);

				}

			}

		else								// currentCount > 0, newCount > 0

			{

			// Find added and modified entries by going through new entries and

			// looking for them in current array

			for(i=0;i<newCount;i++)

				{

				CInstallEntry* newEntry=iCurrentInstallDirEntries[i];

				r=iInstallEntryArray.Find( newEntry, MatchEntries);

				// If we find new entry in current array, check modification date

				if(r>=KErrNone)

					{

					CInstallEntry* currentEntry=iInstallEntryArray[r];

					if( newEntry->Modified() > currentEntry->Modified())

						{												

						// Deal with newly installed file, note use newEntry

						// so we use new timestamp

						newEntry->HandleFileUpdateL(operation);

						}

					}

				else if(r==KErrNotFound)		// File has been added

					{

					// Handle add

					newEntry->HandleFileCreateL(operation);

					// Don't leave on KErrNotFound

					r=KErrNone;

					}

				User::LeaveIfError(r);

				}

			// Find deleted entries by going through current entries and looking for them 

			// in new array

			for(i=0;i<currentCount;i++)

				{

				CInstallEntry* currentEntry=iInstallEntryArray[i];

				r=iCurrentInstallDirEntries.Find( currentEntry, MatchEntries);

				// If we don't find current entry in new array, it's been deleted

				if(r==KErrNotFound)

					{

					// Deal with uninstalls

					currentEntry->HandleFileDeleteL(operation);

					// Don't leave on KErrNotFound

					r=KErrNone;

					}

				User::LeaveIfError(r);

				}

			}

		// Clear out old list

		iInstallEntryArray.ResetAndDestroy();

		// Re-read directory - if any files were corrupt they have been deleted

		// during the merge, so we need to re-read in case this has occurred

		ReadInstallDirL(iInstallEntryArray);

		}

	SaveInstallDirL();

	iCurrentInstallDirEntries.ResetAndDestroy();

	} 

CInstallEntry::CInstallEntry() :

	iUid(KNullUid),

	iModified(0),

	iFileExt(EUnknown)

	{

	}

CInstallEntry::~CInstallEntry()

	{

	if( iRepository)

		{

		iRepository->Close(*iNotifier);

		delete iRepository;

		}

	delete iNotifier;

	}

void CInstallEntry::SetL(TEntry& aEntry)	

	{

	// Get uid from file name

	const TInt KUidLen = 8;

	TPtrC uidPtr=aEntry.iName.Des().LeftTPtr(KUidLen);

	TLex  lex=uidPtr;

	TUint32 uid;

	User::LeaveIfError(lex.Val(uid,EHex)); 

	iUid.iUid=static_cast<TInt32>(uid);

	// save extension type 

	_LIT(KIniFileExtension, ".txt");

	_LIT(KExternalizedFileExt, ".cre");

	const TInt KExtLen = 4;

	TPtrC extPtr=aEntry.iName.Des().RightTPtr(KExtLen);

	if(extPtr.Compare(KIniFileExtension)==0)

		{

		iFileExt=EIni;

		}

	else if(extPtr.Compare(KExternalizedFileExt)==0)

		{

		iFileExt=ECre;

		}

	else

		{

		iFileExt=EUnknown;

		}

	iModified=aEntry.iModified;

	}

void CInstallEntry::ConstructL()	

	{

	// Create repository object

	iRepository = new(ELeave) CServerRepository;

	// Notifier needed to open repositories.		

	iNotifier = new(ELeave)CSessionNotifier ;

	}

CInstallEntry* CInstallEntry::NewL()

	{

	CInstallEntry* self=new(ELeave)CInstallEntry();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

TUid CInstallEntry::Uid() const

	{

	return iUid;

	}

TTime CInstallEntry::Modified() const

	{

	return iModified;

	}

TCentRepFileType CInstallEntry::FileExt() const

	{

	return iFileExt;

	}

void CInstallEntry::ExternalizeL(RWriteStream& aStream) const

	{

 	aStream << iUid.iUid;

	aStream << iModified.Int64();

	TUint32 fileExt=iFileExt;

	aStream << fileExt;

 	}

void CInstallEntry::InternalizeL(RReadStream& aStream)

	{

 	aStream >> iUid.iUid;

 	TInt64 time;

	aStream >> time;

	iModified=time;

	TUint32 fileExt;

	aStream >> fileExt;

	iFileExt =  static_cast<TCentRepFileType>(fileExt);

 	}

void CCentRepSWIWatcher::GetInstallDirL()

	{

	_LIT(KInstallDirFile, "installdir.bin");

	TBuf<KMaxFileName> installDirFilePath;

	installDirFilePath.Append(*TServerResources::iDataDirectory);

	installDirFilePath.Append(KInstallDirFile);

	TEntry entry;

	TInt e = TServerResources::iFs.Entry(installDirFilePath, entry);	

	if(e==KErrNotFound || e==KErrPathNotFound)

		{

		// No file saved - read initial contents of directory

		ReadInstallDirL(iInstallEntryArray);

		SaveInstallDirL();

		return;

		}

	CDirectFileStore* store = 

	    CDirectFileStore::OpenLC (TServerResources::iFs,installDirFilePath, EFileRead|EFileShareReadersOnly);

	if(store->Type()[0] != KDirectFileStoreLayoutUid)

		{

		TServerResources::iFs.Delete(installDirFilePath);

		}

	iInstallEntryArray.ResetAndDestroy();

	// Get the root stream and attempt to read the index from it

	TStreamId rootStreamId = store->Root() ;

	RStoreReadStream rootStream ;

	rootStream.OpenLC(*store, rootStreamId);

	// Internalize the repository	

	TUint32 count;

	rootStream >> count;

	for(TInt i=0; i<count;i++)

		{

		CInstallEntry* installEntry = CInstallEntry::NewL();

		rootStream >> *installEntry;

		CleanupStack::PushL(installEntry);

		User::LeaveIfError(iInstallEntryArray.Append(installEntry));

		CleanupStack::Pop(installEntry);

		}

	CleanupStack::PopAndDestroy(&rootStream);

	CleanupStack::PopAndDestroy(store);

	}

void CCentRepSWIWatcher::SaveInstallDirL() 

	{	

	_LIT(KInstallDirFile, "installdir.bin");

	_LIT(KInstallDirTmpFile, "installdir.tmp");

	TBuf<KMaxFileName> installDirTrnsFilePath;

	installDirTrnsFilePath.Append(*TServerResources::iDataDirectory);

	installDirTrnsFilePath.Append(KInstallDirTmpFile);

	// Create file store

	CDirectFileStore* store = CDirectFileStore::ReplaceLC(TServerResources::iFs, installDirTrnsFilePath,

		                                                      (EFileWrite | EFileShareExclusive));

	const TUid uid2  = KNullUid ;	                                                     

	store->SetTypeL(TUidType(KDirectFileStoreLayoutUid, uid2, KServerUid3)) ; 

	// Write the stream index/dictionary as root stream within the store

	// so we can access it when we do a restore later on

	RStoreWriteStream rootStream ;

	TStreamId rootStreamId = rootStream.CreateLC(*store) ;

	TUint32 count=iInstallEntryArray.Count();

	rootStream << count;

	for(TInt i=0; i<count;i++)

		{

		rootStream << *iInstallEntryArray[i];

		}

	rootStream.CommitL() ;

	CleanupStack::PopAndDestroy(&rootStream) ;

	store->SetRootL(rootStreamId);

	store->CommitL();

	CleanupStack::PopAndDestroy(store) ; 	

	TBuf<KMaxFileName> installDirFilePath;

	installDirFilePath.Append(*TServerResources::iDataDirectory);

	installDirFilePath.Append(KInstallDirFile);

	TEntry entry;

	if(TServerResources::iFs.Entry(installDirFilePath,entry)==KErrNone)

		{

    	User::LeaveIfError(TServerResources::iFs.Replace(installDirTrnsFilePath, installDirFilePath));

		}

	else

		{

		User::LeaveIfError(TServerResources::iFs.Rename(installDirTrnsFilePath, installDirFilePath));

		}   

	}

void CInstallEntry::HandleFileDeleteL(TInt aOperation)

	{

	// File should only have been deleted if operation was uninstall

	// or in startup case

	if((aOperation!=ESwisNone) && (aOperation!=ESwisUninstall))

		User::Leave(KErrAbort);

	// We don't want cache activity during SWI operations

	TServerResources::iCacheManager->DisableCache();

	iRepository->HandleSWIDeleteL(Uid(), *iNotifier);

	// Renable cache activity

	TServerResources::iCacheManager->EnableCache();

	}

void CInstallEntry::HandleFileCreateL(TInt aOperation)

	{

	// File should only have been created if operation was install

	// or in startup case

	if((aOperation!=ESwisNone) && (aOperation!=ESwisInstall))

		User::Leave(KErrAbort);

	// We don't want cache activity during SWI operations

	TServerResources::iCacheManager->DisableCache();

	iRepository->HandleSWIUpdateL(Uid(), Modified(), *iNotifier);

	// Renable cache activity

	TServerResources::iCacheManager->EnableCache();

	}