// 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_noc.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, KSAUidSoftwareInstallKeyValue));

 	// Initialise SWI operation and status

 	TInt swiProperty;

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

 	if (error == KErrNone)

 		{

 		iSWIOperation=swiProperty & KSASwisOperationMask;

 		iSWIStatus= swiProperty & KSASwisOperationStatusMask;

 		}

 	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( ESASwisNone),

 	iSWIStatus( ESASwisStatusSuccess)

 	{

  	CActiveScheduler::Add(this);

 	}

 CCentRepSWIWatcher::~CCentRepSWIWatcher()

 	{

 	Cancel();

 	if(iSWIKey.Handle() != KNullHandle)

 		{

 		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()

 	{	

 	NotifyChange();

 	// Get SWI Key 

 	TInt swiProperty;

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

 	HandleSWIEventL(swiProperty);

 	}

 void CCentRepSWIWatcher::HandleSWIEventL(TInt aSWIProperty)

 	{	

 	iSWIOperation=aSWIProperty & KSASwisOperationMask;

 	iSWIStatus=   aSWIProperty & KSASwisOperationStatusMask;

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

 	// Can't handle aborted restore

 	switch(iSWIOperation)

 		{

 		case ESASwisNone:

 			break;

 		case ESASwisInstall:

 		case ESASwisUninstall:

 			if(iSWIStatus==ESASwisStatusSuccess)

 				{

 				// Handle SWI events

 				FindChangedEntriesL();

 				}

 			else if(iSWIStatus==ESASwisStatusAborted)

 				{

 				// Update directory to reset timestamps

 				ReadInstallDirL(iInstallEntryArray);

 				SaveInstallDirL();

 				}

 			break;

 		case ESASwisRestore:

 			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();

 		}

 	// Renable cache activity in case of errors during SWI events 

 	TServerResources::iCacheManager->EnableCache();

 	return KErrNone;

 	}

 void CCentRepSWIWatcher::DoCancel()

 	{

 	// Cancel subscription to SW P&S flag

 	iSWIKey.Cancel();

 	iSWIKey.Close();

 	}

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

 	{

 	RDir dir;

     CleanupClosePushL(dir);

 	//Empty contents of directory

 	aEntryArray.ResetAndDestroy();

 	// Read contents of install directory

 	User::LeaveIfError(dir.Open(iFs, iInstallDir, KEntryAttNormal));

     TEntryArray dirEntries;

     TInt readError = KErrNone;

 	while (readError != KErrEof)  

 		{

 	    readError = dir.Read(dirEntries);

 	    if(readError != KErrNone && readError != KErrEof) 

 	    	{

 	    	User::Leave(readError);

 	    	}

 	    else

 	    	{

 	    	const TInt dirCount = dirEntries.Count();   

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

 	    		{

 	    		CInstallEntry* installEntry = CInstallEntry::NewL();

 	    		CleanupStack::PushL(installEntry);

 	    		installEntry->SetL(const_cast<TEntry&>(dirEntries[i]));

 	    		if (installEntry->FileExt()==EUnknown)

 	    		    {

 	    		    CleanupStack::PopAndDestroy();

 	    		    }

 	    		else

 	    		    {

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

 	    		    CleanupStack::Pop(installEntry);

 	    		    }

 	    		}

 	    	}

 		}

 	CleanupStack::PopAndDestroy(&dir);

 	}

 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);

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

 	TServerResources::iCacheManager->DisableCache();

 	TRAPD(err, HandleFileChangesL(aStartup));

 	// SWI operations finished, enable cache

 	TServerResources::iCacheManager->EnableCache();

 	User::LeaveIfError(err);

 	} 

 void CCentRepSWIWatcher::HandleFileChangesL(TBool aStartup)

     {

     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=ESASwisNone;

         }

     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();

 		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::ReadAndInternalizeInstallDirL(const TDesC& aInstallDirFilePath)

 	{

 	RFile file;

 	User::LeaveIfError(file.Open(TServerResources::iFs,aInstallDirFilePath, EFileRead|EFileShareReadersOnly));

 	CleanupClosePushL(file);

 	CDirectFileStore* store = CDirectFileStore::FromLC (file);

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

 		{

 		User::Leave(KErrCorrupt);

 		}

 	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(TUint i=0; i<count;i++)

 		{

 		CInstallEntry* installEntry = CInstallEntry::NewL();

 		CleanupStack::PushL(installEntry);

 		rootStream >> *installEntry;

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

 		CleanupStack::Pop(installEntry);

 		}

 	CleanupStack::PopAndDestroy(&rootStream);

 	CleanupStack::PopAndDestroy(store);

 	CleanupStack::PopAndDestroy();

 	}

 void CCentRepSWIWatcher::GetInstallDirL()

 	{

 	_LIT(KInstallDirFile, "installdir.bin");	

 	HBufC* filePath = HBufC::NewLC(TServerResources::iDataDirectory->Length() + KInstallDirFile().Length());

 	TPtr installDirFilePath(filePath->Des());

 	installDirFilePath.Append(*TServerResources::iDataDirectory);

 	installDirFilePath.Append(KInstallDirFile);

 	TRAPD(err, ReadAndInternalizeInstallDirL(installDirFilePath)); // try to open installdir file and internalize its contents

 	if (err != KErrNone) 

 		{

 		TInt fileDeleteErr = TServerResources::iFs.Delete(installDirFilePath);

 		// If a debug build - record error

 		#ifdef _DEBUG

 			if (fileDeleteErr != KErrNone && err != KErrNotFound)

 				{

 				RDebug::Print(_L("CCentRepSWIWatcher::GetInstallDirL - Failed to delete file. Error = %d"), fileDeleteErr);

 				}

 		#else

 			(void)fileDeleteErr;

 		#endif	

 		// No file saved - read initial contents of directory

 		ReadInstallDirL(iInstallEntryArray);

 		SaveInstallDirL();	

 		}		

 	CleanupStack::PopAndDestroy(filePath);		

 	}

 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(TUint 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);

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

 	}

 void CInstallEntry::HandleFileDeleteL(TInt aOperation)

 	{

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

 	// or in startup case

 	if((aOperation!=ESASwisNone) && (aOperation!=ESASwisUninstall))

 		User::Leave(KErrAbort);

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

 	}

 void CInstallEntry::HandleFileCreateL(TInt aOperation)

 	{

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

 	// or in startup case

 	if((aOperation!=ESASwisNone) && (aOperation!=ESASwisInstall))

 		User::Leave(KErrAbort);

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

 	}

 void CInstallEntry::HandleFileUpdateL(TInt aOperation)

 	{

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

 	// or in startup case

 	if((aOperation!=ESASwisNone) && (aOperation!=ESASwisInstall))

 		User::Leave(KErrAbort);

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

 	}