/*
* Copyright (c) 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:
*
*/
#include "CdlSFiles.h"
#include "CdlServer.h"
#include <e32uid.h>

const TUid KCdlLibraryUid = { 0x101F8BD1 };

_LIT(KCdlLibsPath,"*:\\sys\\bin");

CCdlRefCollection* CCdlDllsWatcherBase::FileContentsLC(const TDesC& aFileName)
	{
	return CdlServerEngine::FileContentsLC(aFileName);
	}

//
// CCdlDirs
//

const TInt KCCdlDirsGranularity = 4;

CCdlDirs::CCdlDirs()
: CArrayPtrFlat<CDir>(KCCdlDirsGranularity)
	{
	}

CCdlDirs::~CCdlDirs()
	{
	ResetAndDestroy();
	}


//
// CFsWatcher
//

CFsWatcher::CFsWatcher(RFs& aFs, MFsWatcherObserver& aObserver)
: CActive(EPriorityStandard), iFs(aFs), iObserver(aObserver)
	{
	CActiveScheduler::Add(this);
	Queue();
	}

CFsWatcher::~CFsWatcher()
	{
	Cancel();
	}

void CFsWatcher::ConstructL()
	{
	}

CCdlDirs* CFsWatcher::CreateDirsListL() const
	{
	CCdlDirs* dirs = new(ELeave) CCdlDirs();
	CleanupStack::PushL(dirs);

	TDriveList drives;
	User::LeaveIfError(iFs.DriveList(drives));
	TFileName path(KCdlLibsPath);
	path.Append('\\');
	for (TInt drive = EDriveZ; drive >= EDriveA; drive--)
		{
		if (drives[drive])
			{
			path[0] = TText('A' + drive);
			CDir* fileList=NULL;
			const TUidType dllType(KDynamicLibraryUid, KCdlLibraryUid);
			if (iFs.GetDir(path, dllType, ESortByName, fileList) == KErrNone)
				{
				CleanupStack::PushL(fileList);
				dirs->AppendL(fileList);
				CleanupStack::Pop(fileList);
				}
			}
		}

	CleanupStack::Pop(dirs);
	return dirs;
	}

void CFsWatcher::DoCancel()
	{
	iFs.NotifyChangeCancel();
	}

void CFsWatcher::RunL()
	{
	// errors in the FS watcher can't be reported sensibly, so they are ignored.
	TRAPD(ignore, DoRunL());
	}

void CFsWatcher::DoRunL()
	{
	// error from RFs::NotifyChange will stop the watcher
	User::LeaveIfError(iStatus.Int());
	Queue();
	// error from CreateDirsListL, most likely OOM, will stop the change from being processed
	// immediately, but further changes will make it catch up.
	iObserver.NewDirsList(CreateDirsListL());
	}

void CFsWatcher::Queue()
	{
	iFs.NotifyChange(ENotifyAll, iStatus, KCdlLibsPath);
	SetActive();
	}


//
// CCdlDllsWatcher
//

void CCdlDllsWatcherBase::NewL(CCdlDllsWatcherBase*& iWatcher, RFs& aFs, MCdlDllsObserver* aObserver)
	{
	CCdlDllsWatcher* self = new(ELeave) CCdlDllsWatcher(aFs, aObserver);
	iWatcher = self;
	self->ConstructL();
	}

CCdlDllsWatcher::CCdlDllsWatcher(RFs& aFs, MCdlDllsObserver* aObserver)
: CCdlDllsWatcherBase(aFs), iObserver(aObserver)
	{
	}

CCdlDllsWatcher::~CCdlDllsWatcher()
	{
	delete iFsWatcher;
	delete iCurrent.iDirs;
	delete iNew.iDirs;
	delete iNext;
	Cancel();
	}

void CCdlDllsWatcher::ConstructL()
	{
	iFsWatcher = new(ELeave) CFsWatcher(iFs, *this);
	iFsWatcher->ConstructL();
	iNew.iDirs = iFsWatcher->CreateDirsListL();
	iNew.Reset();
	Queue();
	}

void CCdlDllsWatcher::DoCancel()
	{
	}

void CCdlDllsWatcher::RunL()
	{
	// errors here will be caused by leaves in the observer. These should not stop
	// processing of further DLLs. So, errors are ignored.
	TRAPD(ignore, DoRunL());
	}

void CCdlDllsWatcher::DoRunL()
	{
	if (iCurrent.AtEnd() && iNew.AtEnd())	// At end of both queues, restart if there is a pending dirs list

		{
		delete iCurrent.iDirs;
		iCurrent.iDirs = iNew.iDirs;
		iCurrent.Reset();

		iNew.iDirs = iNext;
		iNext = NULL;
		iNew.Reset();

		if (iNew.iDirs)
			Queue();

		if (iTellingObserver)
			{
			iTellingObserver = EFalse;
			iObserver->McdoChangesCompleteL();
			}
		}
	else if (iCurrent.AtEnd())				// at end of current list, any DLLs left in new list should be added
		{
		AddNewToObserverL();
		}
	else if (iNew.AtEnd())					// at end of new list, any DLLs left in current list should be removed
		{
		RemoveCurrentFromObserverL();
		}
	else if (iCurrent == iNew)				// DLLs are the same, skip to the next one
		{
		iCurrent.Next();
		iNew.Next();
		Queue();
		}
	else if (iCurrent < iNew)				// current DLL does not appear in new list, remove it
		{	
		// note: it is important to check for deletes before adds, because the
		// two files may have the same name but different times.
		RemoveCurrentFromObserverL();
		}
	else									// new DLL does not appear in current list, add it
		{
		AddNewToObserverL();
		}
	}

void CCdlDllsWatcher::AddNewToObserverL()
	{
	const TEntry& file = iNew.Current();
	iNew.Next();
	Queue();
	StartTellingObserverIfNecessaryL();
	iObserver->McdoFileAddedL(file.iName);
	}

void CCdlDllsWatcher::RemoveCurrentFromObserverL()
	{
	const TEntry& file = iCurrent.Current();
	iCurrent.Next();
	Queue();
	StartTellingObserverIfNecessaryL();
	iObserver->McdoFileRemovedL(file.iName);
	}

void CCdlDllsWatcher::StartTellingObserverIfNecessaryL()
	{
	if (!iTellingObserver)
		iObserver->McdoPrepareForChangesL();
	iTellingObserver = ETrue;
	}

void CCdlDllsWatcher::Queue()
	{
	iStatus = KRequestPending;
	TRequestStatus* s = &iStatus;
	User::RequestComplete(s, KErrNone);
	SetActive();
	}

void CCdlDllsWatcher::NewDirsList(CCdlDirs* aNewDirs)
	{
	if (IsActive())
		{
		delete iNext;
		iNext = aNewDirs;
		}
	else
		{
		iNew.iDirs = aNewDirs;
		iNew.Reset();
		Queue();
		}
	}


//
// CCdlDllsWatcher::TDllList
//

void CCdlDllsWatcher::TDllList::Reset()
	{
	Mem::FillZ(iIndices, sizeof(TInt)*KMaxDrives);
	SetCurrent();
	}

TBool CCdlDllsWatcher::TDllList::operator==(const TDllList& aRhs) const
	{
	__ASSERT_ALWAYS(iCurrent, Panic(EPanicTDllListOpEqNullCurrent));

	const TEntry& rhsEntry = aRhs.Current();
	return	iCurrent->iName.CompareF(rhsEntry.iName) == 0 &&
			iCurrent->iModified == rhsEntry.iModified;
	}

TBool CCdlDllsWatcher::TDllList::operator<(const TDllList& aRhs) const
	{
	__ASSERT_ALWAYS(iCurrent, Panic(EPanicTDllListOpLtNullCurrent));

	const TEntry& rhsEntry = aRhs.Current();
	TInt cmp = iCurrent->iName.CompareF(rhsEntry.iName);
	return	cmp < 0 || (cmp == 0 && iCurrent->iModified < rhsEntry.iModified);
	}

const TEntry& CCdlDllsWatcher::TDllList::Current() const
	{
	__ASSERT_ALWAYS(iCurrent, Panic(EPanicTDllListCurrentNullCurrent));

	return *iCurrent;
	}

TBool CCdlDllsWatcher::TDllList::AtEnd() const
	{
	if (!iDirs)
		return ETrue;

	return !iCurrent;
	}

void CCdlDllsWatcher::TDllList::Next()
	{
	__ASSERT_ALWAYS(iCurrent, Panic(EPanicTDllListNextNullCurrent));
	__ASSERT_ALWAYS(iDirs, Panic(EPanicTDllListNextNullDirs));

	TInt count = iDirs->Count();
	for (TInt ii = 0; ii < count; ii++)
		{
		CDir& dir = *iDirs->At(ii);
		if (iIndices[ii] < dir.Count())
			{
			const TEntry& entry = dir[iIndices[ii]];
			if (entry.iName.CompareF(iCurrent->iName) == 0)
				iIndices[ii]++;
			}
		}

	SetCurrent();
	}

void CCdlDllsWatcher::TDllList::SetCurrent()
	{
	// This function implements the CDL drive priority rule, 
	// where DLLs on Z are higher priority than Y...
	// nb. Z: is the first in iDirs, A: is last.

	iCurrent = NULL;
	if (!iDirs)
		return;

	TInt count = iDirs->Count();
	for (TInt ii = 0; ii < count; ii++)
		{
		CDir& dir = *iDirs->At(ii);
		if (iIndices[ii] < dir.Count())
			{
			const TEntry& entry = dir[iIndices[ii]];
			if (!iCurrent || entry.iName.CompareF(iCurrent->iName) < 0)
				iCurrent = &entry;
			}
		}
	}

TInt CCdlDllsWatcher::IsPluginInRom(const TDesC& /*aFileName*/, TBool& /*aIsInRom*/) const
	{
	return KErrNotSupported;
	}