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

// BIODB.CPP

//

#include "BIODB.H"

#include "BDBPAN.H"

#include "cbifentry.h"

#include <s32file.h>		// CFileStore

#include <bautils.h>

#include <basched.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS 

#include <bifchangeobserver.h>

#endif

//

// Globals & Constants

//

// Old search paths are /system/bif

// New (platsec) search paths are /resource/messaging/bif

_LIT(KSecureBifPath, "\\resource\\messaging\\Bif\\");     

_LIT(KSecureBifSearchString, "?:\\resource\\messaging\\Bif\\");

_LIT(KLanguageFileExt, ".r");

_LIT(KDotRsc, ".rsc");

// 30 seconds between attempts to scan drives if we get completed with an error,

const TInt KBifRetryTimeOut=30000000;

// Maximam attempts to scan drives if we get completed with an error,

const TInt KMaxRetries = 1;

// default size of array of entries in a bif directory

const TInt KBifEntryArrayDefaultSize=5;

const TInt KMinFileNameLength = 5;

/*

 *	CBifChangeObserver

 */

/** Allocates and constructs a new BIF change observer.

@param	aObserver 

Callback interface to notify when a change occurs

@param	afileSystem 

Connected file system handle

@return 

New BIF change observer 

*/

EXPORT_C CBifChangeObserver* CBifChangeObserver::NewL(MBifChangeObserver& aObserver, RFs& aFs)

	{

	CBifChangeObserver* self=new(ELeave) CBifChangeObserver(aObserver, aFs);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CBifChangeObserver::ConstructL()

	{

	iBioDB = CBIODatabase::NewL(iFs);

	User::LeaveIfError(iTimer.CreateLocal());

	}

CBifChangeObserver::CBifChangeObserver(MBifChangeObserver& aObserver, RFs& aFs)

: CActive(EPriorityStandard), iChangeObserver(aObserver), iFs(aFs)

	{

	CActiveScheduler::Add(this);

	}

/** Destructor. */

CBifChangeObserver::~CBifChangeObserver()

	{

	Cancel();

	iTimer.Close();

	delete iBioDB;

	iEntries.ResetAndDestroy();

	}

/** Starts the object watching for changes.

To stop the object, simply delete it.

*/

EXPORT_C void CBifChangeObserver::Start()

	{

	// just complete myself so that RunL builds the list of entries and asks the file

	// sever to notify us of changes.

	TRequestStatus *status=&iStatus;

	User::RequestComplete(status,KErrNone);

	SetActive();

	}

void CBifChangeObserver::RunL()

	{

	TInt err=KErrNone;

	if(iStatus.Int()==KErrNone)

		{

		// ignore the error

		TRAP(err, DoRunL());

		}

#ifdef _DEBUG

 	else

		{

		// I don't expect to get here, it means that RFs::NotifyChangeL has completed

		// this class with an error, which means we would loop rather quickly.

		User::Invariant();

		}

#endif

	if((iStatus.Int() != KErrNone || err != KErrNone) && iRetryCount < KMaxRetries)

		{

		iTimer.After(iStatus,KBifRetryTimeOut);

		iRetryCount ++;

		SetActive();

		}

	else

		{

		WaitForFileNotification();	

		iRetryCount = 0;

		}

	}

void CBifChangeObserver::DoRunL()

    {

    TBool notify=EFalse;

	// build a list of all the TEntrys in KBifPath on all drives/

	RPointerArray<CBifEntry> entryList(KBifEntryArrayDefaultSize);

	TCleanupItem cleanup(CleanupBifArray, &entryList);

	CleanupStack::PushL(cleanup);

	TFindFile fileFinder(iFs);     

	CDir *dir=NULL;     

	// Scan this folder from V1.5 onwards

	TInt err = fileFinder.FindWildByDir(_L("*"),KSecureBifPath,dir);

	while(err==KErrNone)

		{

		CleanupStack::PushL(dir);

		TInt count=dir->Count();

		while(count--)

			{

			CBifEntry* bifEntry = CBifEntry::NewLC((*dir)[count]);

			entryList.AppendL(bifEntry);

			CleanupStack::Pop(bifEntry);

			}

		CleanupStack::PopAndDestroy(dir);

		err=fileFinder.Find();

		} 

	if (err != KErrNotFound)

		User::LeaveIfError(err);

	// Check to see if iEntries matches entryList

	if(iEntries.Count()!=0) // iEntries is empty the first time in so don't notify anyone.

		{

		// check to see if the two lists of entries are the same

		if(iEntries.Count()!=entryList.Count())

			notify=ETrue;  // not the same if one is larger than the other

		else

			{

			TInt count=entryList.Count();

			while(count-- && notify==EFalse)

				{

				TInt index;

				TInt found=FindEntry(*(entryList)[count],iEntries,index);

				if(found==KErrNone)

					{

					delete (iEntries)[index];

					iEntries.Remove(index);

					}

				else

					notify=ETrue; // not the same if entryList contains something not in iEntries

				}

			if(iEntries.Count()!=0)

				notify=ETrue; // not the same if iEntries contains something not in entryList;

			}

		}

	// replace old iEntries with new entryList

	CleanupStack::Pop(&entryList);

	iEntries.ResetAndDestroy();

	iEntries=entryList;

	// notify observers if iEntries was != entryList;

	if(notify!=EFalse) 

		NotifyObserverL();

	}

TInt CBifChangeObserver::FindEntry(const CBifEntry& aBifEntry, const RPointerArray<CBifEntry>& aEntries, TInt& aIndex) const

	{

	aIndex = aEntries.Count();

	while (aIndex--)

		{

		if ( aBifEntry == *aEntries[aIndex] )

			{

			return KErrNone;

			}

		}

	return KErrNotFound;

	}

void CBifChangeObserver::WaitForFileNotification()

	{

	// Observe this folder from V1.5 onwards

	iFs.NotifyChange(ENotifyAll, iStatus, KSecureBifSearchString);

	SetActive();

	}

void CBifChangeObserver::DoCancel()

	{

    iTimer.Cancel();

	iFs.NotifyChangeCancel(iStatus);	// Cancel only the specific

										// request made by this observer

	}

TBool CBifChangeObserver::CompareReaders(const CBioInfoFileReader& aReader1, const CBioInfoFileReader& aReader2) const

	{

	TBool retVal = aReader1.BifEntry() == aReader2.BifEntry();

	if (retVal)

		{

		//Compare the readers

		retVal = 

			   (aReader1.MessageParserName().Compare(aReader2.MessageParserName()) == 0)

			&& (aReader1.MessageAppCtrlName().Compare(aReader2.MessageAppCtrlName()) == 0)

			&& (aReader1.MessageAppUid() == aReader2.MessageAppUid())

			&& (aReader1.GeneralData1() == aReader2.GeneralData1())

			&& (aReader1.GeneralData2() == aReader2.GeneralData2())

			&& (aReader1.GeneralData3() == aReader2.GeneralData3())

			&& (aReader1.IconsFilename().Compare(aReader2.IconsFilename()) == 0)

			&& (aReader1.Description().Compare(aReader2.Description()) == 0);

		//To Do: Should aReader1.IdsLC() and aReader2.IdsLC() be compared?

		}

	return retVal;

	}

void CBifChangeObserver::NotifyObserverL()

	{

	CArrayFixFlat<TUid>* addedBifs = new (ELeave) CArrayFixFlat<TUid>(1);

	CleanupStack::PushL(addedBifs);

	CArrayFixFlat<TUid>* changedBifs = new (ELeave) CArrayFixFlat<TUid>(1);

	CleanupStack::PushL(changedBifs);

	CArrayFixFlat<TUid>* deletedBifs = new (ELeave) CArrayFixFlat<TUid>(1);

	CleanupStack::PushL(deletedBifs);

	// Figure out what kind of change really happened here

	CBIODatabase* newBioDB = CBIODatabase::NewL(iFs);

	CleanupStack::PushL(newBioDB);

	TInt err = KErrNone;

	TUid uid;

	TInt index = 0;

	TKeyArrayFix key(0, ECmpTInt);

	TInt count = newBioDB->BIOCount();

	while (count--)

		{

		newBioDB->GetBioMsgID(count, uid);

		TRAP(err, iBioDB->GetBioIndexWithMsgIDL(uid, index));

		if (err)

			{

			//BIF in New BIO DB not found in Old BIO DB

			addedBifs->InsertIsqL(uid, key);

			}

		else

			{

			//BIF in both BIO DBs, therefore check to see if the files have changed

			if  (!CompareReaders(iBioDB->BifReader(index), newBioDB->BifReader(count)))

				{

				changedBifs->InsertIsqL(uid, key);

				}

			//Remove this BIF from the Old BIO DB for efficiency in the next while loop.

			iBioDB->RemoveBifL(index);

			}

		}

	count = iBioDB->BIOCount();

	while (count--)

		{

		//All remaining members of iBioDB are deleted BIFs

		iBioDB->GetBioMsgID(count, uid);

		deletedBifs->InsertIsqL(uid, key);

		}

	count = addedBifs->Count();

	while (count--)

		{

		iChangeObserver.HandleBifChangeL(MBifChangeObserver::EBifAdded, addedBifs->At(count));

		}

	count = deletedBifs->Count();

	while (count--)

		{

		iChangeObserver.HandleBifChangeL(MBifChangeObserver::EBifDeleted, deletedBifs->At(count));

		}

	count = changedBifs->Count();

	while (count--)

		{

		iChangeObserver.HandleBifChangeL(MBifChangeObserver::EBifChanged, changedBifs->At(count));

		}

	// update the list we're holding onto

	delete iBioDB;

	iBioDB = newBioDB;

	CleanupStack::Pop(); //newBioDB

  	CleanupStack::PopAndDestroy(3); //arrays

	}

void CBifChangeObserver::CleanupBifArray( TAny* aBifArray )

	{

	RPointerArray<CBifEntry>* bifArray = static_cast<RPointerArray<CBifEntry>*>(aBifArray);

	bifArray->ResetAndDestroy();

	}

//

// CBIODatabase

//

//

// Construction

//	protected

//

CBIODatabase::CBIODatabase()

	{

	// We're a CBase derived class so we can assume that our data members are intialized to 0

	}

//

EXPORT_C CBIODatabase* CBIODatabase::NewLC(RFs& afileSystem)

/** Allocates and constructs a new BIO database object, leaving the object on the 

cleanup stack.

It initialises the object from all the BIF files in the system\\bif directory.

@param afileSystem Connected file system handle

@return New BIO database object */

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(afileSystem);

	return self;

	}

//

EXPORT_C CBIODatabase* CBIODatabase::NewL(RFs& afileSystem)

/** Allocates and constructs a new BIO database object.

It initialises the object from all the BIF files in the system\\bif directory.

@param afileSystem Connected file system handle

@return New BIO database object */

	{

	CBIODatabase* self=CBIODatabase::NewLC(afileSystem);

	CleanupStack::Pop();		// self

	return self;

	}

//

// Construction/destruction

void CBIODatabase::ConstructL(RFs& afileSystem)

	{

	// put the real construction here

	iBifReaders= new (ELeave) CArrayPtrFlat<CBioInfoFileReader>(10);

	AddAllBifsL(afileSystem);

	}

//

// Construction/destruction

EXPORT_C CBIODatabase::~CBIODatabase()

/** Destructor. */

	{

	if (iBifReaders)

		iBifReaders->ResetAndDestroy();

	delete iBifReaders;

	}

//

EXPORT_C TInt CBIODatabase::BIOCount()

/** Gets the number of BIF files.

@return Number of BIF files */

	{

	return iBifReaders->Count();

	}

//

EXPORT_C void CBIODatabase::AddAllBifsL(RFs& afileSystem)

/** Initialises the object from all the BIF files in the system\\bif or resource\\messaging\\bif directory.

@param afileSystem Connected file system handle */

	{

	// Walk through all the BIF Files, adding each one

	// to the iBifReaders array

	TDriveList drvList;

	// User::LeaveIfError(afileSystem.Connect());

	User::LeaveIfError(afileSystem.DriveList(drvList));

	for (TInt n=0 ; n<KMaxDrives ; ++n)

		{

		if (drvList[n]!=0)

			{

			TDriveInfo driveinfo;

			TInt ret=afileSystem.Drive(driveinfo,n);

			if ((ret==KErrNone) && (driveinfo.iType!=EMediaNotPresent) && (driveinfo.iType!=EMediaRemote) 

												&& (!(driveinfo.iMediaAtt & KMediaAttLocked)) )

				{

				TDriveUnit driveUnit(n);

				TPath fullPath; // Length must hold x:\resource\messaging\bif\ 

				fullPath.FillZ();

				fullPath = driveUnit.Name();

				fullPath += KSecureBifPath;

				if (afileSystem.SetSessionPath(fullPath) == KErrNone)

					{

					CDir* entryList = NULL;

					// Walk through all the BIF Files, adding each one

 					ret = afileSystem.GetDir( fullPath,

											  KEntryAttNormal|KEntryAttAllowUid,

											  ESortByDate,

											  entryList );

					if (ret==KErrNone)

						{

						CleanupStack::PushL(entryList);

						TInt cnt = entryList->Count();

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

							{

							// get the file

							TEntry entry = (*entryList)[i];

								TFileName fileName(fullPath);

								fileName.Append(entry.iName);

								// Remove localization index from the filename and replace it with "rsc"

								// example, abc.r05 -> abc.rsc

								TInt extLength(0);

								if ( IsLanguageFileL(entry.iName, extLength) && (fileName.Length() >= KMinFileNameLength) )

									{

									fileName.Replace(fileName.Length() - extLength, extLength, KDotRsc);

									}

								// Use the file most appropriate to the current language

								BaflUtils::NearestLanguageFile(afileSystem,fileName);

								// Load the bif file

								CBioInfoFileReader* bifReader = NULL;

								TRAPD(error, bifReader=CBioInfoFileReader::NewL(afileSystem,fileName));

								if (!error)

									{

									AddBifL(bifReader);									

									}

								else

									{

									// Ignore corrupt files

									delete bifReader;

									if (error != KErrCorrupt && error != KErrExtended && error != KErrNotFound)

										{

										User::LeaveIfError(error);

										}

									}

							}

						CleanupStack::PopAndDestroy(entryList); 

						}

					}

				}

				if (!(ret==KErrNone || 

					  ret==KErrPathNotFound || 

					  ret==KErrNotFound || 

					  ret==KErrNotReady  || 

					  ret==KErrCorrupt ||

					  ret==KErrInUse ||

					  ret==KErrLocked || 

					  ret==KErrNotSupported))

					{

					User::LeaveIfError(ret);

					}

			}

		}

	}

// Is the file a language file

TBool CBIODatabase::IsLanguageFileL(const TDesC& aFileName, TInt& aExtLength) const

	{

	// Check the extension to see if it's a language file. we

 	// have to assume ".rXXX" is a resource file

 	TParse parse;

 	User::LeaveIfError(parse.Set(aFileName, NULL, NULL));

	aExtLength=parse.Ext().Length();

 	return parse.Ext().Left(2).CompareF(KLanguageFileExt) == 0;

	}

//