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

// f32\sfile\sf_notifier.cpp

// 

//

#include "sf_notifier.h"

#include "sf_file_cache.h"

CFsObjectCon* FsNotificationManager::iNotifyRequests = NULL;

RFastLock FsNotificationManager::iChainLock;

TInt FsNotificationManager::iFilterRegister[];

CFsPool<CFsNotificationBlock>* FsNotificationManager::iPool;

CFsNotificationPathFilter* CFsNotificationPathFilter::NewL(const TDesC& aPath, const TDesC& aFilename, TInt aDriveNum)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aPath,aFilename,aDriveNum);

	CleanupStack::Pop(self);

	return self;

	}

void CFsNotificationPathFilter::ConstructL(const TDesC& aPath, const TDesC& aFilename, TInt aDriveNum)

	{

	//Allocate the path and filename

	iPath = aPath.AllocL();

	iFilename = aFilename.AllocL();	

	iDriveNum = aDriveNum;

	}

CFsNotificationPathFilter::~CFsNotificationPathFilter()

	{

	if(iFilename)

		delete iFilename;

	if(iPath)

		delete iPath;

	}

CFsNotificationPathFilter::CFsNotificationPathFilter()

: iPath(NULL), iFilename(NULL)

	{

	}

CFsNotifyRequest* CFsNotifyRequest::NewL()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

void CFsNotifyRequest::ConstructL()

	{

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

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

	}

CFsNotifyRequest::CFsNotifyRequest()

	{

	SetActive(EInactive);

	}

CFsNotifyRequest::~CFsNotifyRequest()

	{

	__PRINT(_L("CFsNotifyRequest::~CFsNotifyRequest()"));

	RemoveFilters();

	if(ClientMsgHandle()!=0)

		iClientMsg.Complete(KErrCancel);

	if(iBufferMsg.Handle()!=0)

		iBufferMsg.Complete(KErrCancel);

	iClientSyncLock.Close();

	iTailSemaphore.Close();

	}

/*

 * Returns the Array of TypeFilters.

 * Each TFsNotificationTypeFilter matches to a particular TFsNotification::TFsNotificationType

 * and has a CFsNotificationFilter which stores the iPath and iName associated with this filter type.

 * 

 * (These are speerated so that we can have multiple type filters for every name filter)

 */

TFsNotificationTypeArray* CFsNotifyRequest::FilterTypeList(TInt aDrive,TInt aIndex)

	{

	__ASSERT_DEBUG(aIndex < KNumRegisterableFilters,Fault(ENotificationFault));

	TFsNotificationTypeDriveArray* filters = iDrivesTypesFiltersMap.Find(aDrive);

	if(filters)

		return &((*filters)[aIndex]);

	else

		return NULL;

	}

//Sets filter's notification request status

void CFsNotifyRequest::SetActive(TNotifyRequestStatus aValue)

	{

	iNotifyRequestStatus = aValue;

	}

CFsNotifyRequest::TNotifyRequestStatus CFsNotifyRequest::ActiveStatus()

	{

	return (TNotifyRequestStatus)iNotifyRequestStatus;

	}

//Completes and frees notification request

//In case of KErrNone must be called with iChainLock already held

void CFsNotifyRequest::CompleteClientRequest(TInt aReason,TBool aIsCancel)

	{

	__PRINT(_L("CFsNotifyRequest::CompleteClientRequest()"));

	iClientSyncLock.Wait();

	if(aReason==KErrNone) 

		{

		__PRINT(_L("CFsNotifyRequest::CompleteClientRequest() - Complete KErrNone"));

		//Synchronising the current iServerTail to the client.

		iClientHead = iClientTail; //Client has read all previous entries

		iClientTail = iServerTail; //Client's new tail is everything the server has been writing since this function was last called

		TInt clientTail = iClientTail;

		TPckg<TInt> tailDes(clientTail);

		iClientMsg.Write(KMsgPtr0,tailDes);

		}

	else if(aIsCancel)

		{

		__PRINT(_L("CFsNotifyRequest::CompleteClientRequest() - Complete isCancel"));

		iServerTail = 0;

		iClientTail = 0;

		iClientHead = 0;

		TPckgBuf<TInt> tailDes(iClientTail);

		//Perhaps client has crashed so no point checking return:

		iClientMsg.Write(KMsgPtr0,tailDes); 

		}

	__PRINT(_L("CFsNotifyRequest::CompleteClientRequest() - Complete Request"));

	iClientMsg.Complete(aReason);

	iClientSyncLock.Signal();

	}

TInt CFsNotifyRequest::SynchroniseBuffer(CFsNotificationBlock& aBlock,TInt aServerTail, TInt aNotificationSize)

	{

	TPtrC8 blockDes((TText8*)aBlock.Data(),aNotificationSize);

	return iBufferMsg.Write(KMsgPtr0,blockDes,aServerTail);

	}

//Removes all filters.

//Deletes iPath, iFilename

TInt CFsNotifyRequest::RemoveFilters()

	{

	__PRINT(_L("CFsNotifyRequest::RemoveFilters()"));

	//For every drive with filters set...

	RHashMap<TInt,TFsNotificationTypeDriveArray>::TIter iterator(iDrivesTypesFiltersMap);

	TFsNotificationTypeDriveArray* currentDriveFilters = (TFsNotificationTypeDriveArray*)iterator.NextValue();

	while(currentDriveFilters)

		{

		//For every filter array (1 for each type of TFsNotificationType)

		for(TInt filterType = 0; filterType < KNumRegisterableFilters; filterType++)

			{

			TFsNotificationTypeArray& filterList = (*currentDriveFilters)[filterType];

			TInt filterTypeCount = filterList.Count();

			if(filterTypeCount)

				{

				//Remove this type from the filter register

				TFsNotification::TFsNotificationType type = CFsNotificationInfo::NotificationType(filterType);

				FsNotificationManager::SetFilterRegister(type,EFalse,filterTypeCount);

				}

			filterList.Reset();

			filterList.Close();

			}

		currentDriveFilters->Reset();

		currentDriveFilters->Close();

		iterator.RemoveCurrent();

		currentDriveFilters = (TFsNotificationTypeDriveArray*)iterator.NextValue();

		}

	iDrivesTypesFiltersMap.Close();

	return KErrNone;

	}

TInt CFsNotifyRequest::AddFilterL(CFsNotificationPathFilter* aFilter, TUint aMask)

	{

	__PRINT(_L("CFsNotifyRequest::AddFilterL"));

	//Get the drive number to so know which drive array to add the filter(s) to.

	TInt driveNum = aFilter->iDriveNum; 

	TInt notifyType = 1; 

	TInt r = KErrNone;

	//Create/Add a TypeFilter for each type in aMask

	while((notifyType & KNotificationValidFiltersMask) && (aMask & KNotificationValidFiltersMask))

		{

		//If this notifyType is present in aMask

		if(aMask & notifyType)

			{

			TFsNotificationTypeFilter typeFilter;

			typeFilter.iNotificationType = (TFsNotification::TFsNotificationType) notifyType;

			typeFilter.iPathFilter = aFilter;

			TInt index = CFsNotificationInfo::TypeToIndex(typeFilter.iNotificationType);

			//If the per-drive-filterLists have not

			//been set up yet then do so now.

			TFsNotificationTypeDriveArray* driveArray = iDrivesTypesFiltersMap.Find(driveNum);

			if(!driveArray)

				{

				TFsNotificationTypeDriveArray dArray;

				r = iDrivesTypesFiltersMap.Insert(driveNum,dArray);

				User::LeaveIfError(r);					

				driveArray = iDrivesTypesFiltersMap.Find(driveNum);

				//Create filter arrays for every type

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

					{

					TFsNotificationTypeArray filterArray;

					driveArray->Append(filterArray);

					}

				}

			TFsNotificationTypeArray& filterArray= (*driveArray)[index];

			filterArray.Append(typeFilter);

			//Remove this type from our mask

			//and continue

			aMask ^= notifyType;

			}

		notifyType <<= 1;

		}

	return r;

	}

TInt CFsNotifyRequest::SetClientMessage(const RMessage2& aClientMsg)

	{

	__PRINT(_L("CFsNotifyRequest::SetClientMessage"));

	iClientMsg = aClientMsg;

	return KErrNone;

	}

TInt CFsNotifyRequest::ClientMsgHandle()

	{

	return iClientMsg.Handle();

	}

const RMessage2& CFsNotifyRequest::BufferMessage()

    {

    return iBufferMsg;

    }

void CFsNotifyRequest::CloseNotification()

	{

	__PRINT(_L("CFsNotifyRequest::CloseNotification()"));

	iBufferMsg.Complete(KErrNone);

	if(ClientMsgHandle()!=0)

		CompleteClientRequest(KErrCancel,EFalse);

	}

//New notification request from client

void FsNotificationManager::AddNotificationRequestL(CFsNotifyRequest* aNotificationRequest)

	{

	__PRINT(_L("FsNotificationManager::AddNotificationRequestL"));

	Lock();

	iNotifyRequests->AddL(aNotificationRequest,ETrue);

	Unlock();

	}

//Notification request cancelled

//Must be called with iChainLock held

void FsNotificationManager::RemoveNotificationRequest(CFsNotifyRequest* aNotificationRequest)

	{

	__PRINT(_L("FsNotificationManager::RemoveNotificationRequest"));

	iNotifyRequests->Remove(aNotificationRequest,ETrue);

	}

void FsNotificationManager::RemoveNotificationRequest(CSessionFs* aSession)

	{

	__PRINT(_L("FsNotificationManager::RemoveNotificationRequest(CSessionFs*)"));

	TInt count = Count();

	if(count)

		{

		Lock();

		count = Count(); //check again just incase it's changed before we got the lock

		if(count)

			{

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

				{

				//Remove all notification requests associated with this session.

				CFsNotifyRequest* notify = (CFsNotifyRequest*)(*iNotifyRequests)[i];

				if(notify->iSession == aSession)

					{

					RemoveNotificationRequest(notify);

					delete notify;

					}

				}

			if(!Count())

				{

				__PRINT(_L("FsNotificationManager::RemoveNotificationRequest(CSessionFs*) - Closing Manager"));

				Close();

				}

			}

		Unlock();

		}

	}

TBool FsNotificationManager::IsInitialised()

	{

	__PRINT(_L("FsNotificationManager::IsInitialised()"));

	return (TBool)iNotifyRequests;

	}

void FsNotificationManager::OpenL()

	{

	__PRINT(_L("FsNotificationManager::InitialiseL()"));

	if(!iNotifyRequests)

		{

		if(iChainLock.Handle() == 0)

			{

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

			}

		iNotifyRequests = TheContainer->CreateL();

		iPool = CFsPool<CFsNotificationBlock>::New(KNotificationPoolSize,CFsNotificationBlock::New);

		User::LeaveIfNull(iPool);

		}

	}

void FsNotificationManager::SetFilterRegister(TUint aFilter, TBool aAdd, TInt aCount)

	{

	__PRINT2(_L("FsNotificationManager::SetFilterRegister(aFilter=%u,aAdd=%d)"),aFilter,aAdd);

	TInt index = CFsNotificationInfo::TypeToIndex((TFsNotification::TFsNotificationType)aFilter);

	TInt& fr = FsNotificationManager::FilterRegister(index);

	__ASSERT_DEBUG((aAdd) ? fr >= 0 : fr > 0,Fault(ENotificationFault));

	fr+= aAdd ? aCount : -aCount; 

	}

void FsNotificationManager::SetFilterRegisterMask(TUint aMask,TBool aAdd)

	{

	__PRINT(_L("FsNotificationManager::RegisterFilterMask()"));

	TInt notifyType = 1; 

	while(notifyType & KNotificationValidFiltersMask && aMask & KNotificationValidFiltersMask)

		{

		if(aMask & notifyType)

			{

			SetFilterRegister(notifyType,aAdd);

			aMask ^= notifyType;

			}

		notifyType <<= 1;

		}

	}

TInt& FsNotificationManager::FilterRegister(TInt aIndex)

	{

	__PRINT(_L("FsNotificationManager::FilterRegister()"));

	__ASSERT_DEBUG(aIndex < KNumRegisterableFilters,Fault(ENotificationFault));

	return iFilterRegister[aIndex];

	}

//Must be called with the iChainLock

void FsNotificationManager::Close()

	{

	__PRINT(_L("FsNotificationManager::Stop()"));

	CFsObjectCon*& request = iNotifyRequests;

	if(request)

		{

		TheContainer->Delete(request);

		delete iPool;

		iPool = NULL;

		}

	request = NULL;

	}

TInt FsNotificationManager::Count()

	{

	__PRINT(_L("FsNotificationManager::Count()"));

	if(IsInitialised())

		return iNotifyRequests->Count();

	return 0;

	}

void FsNotificationManager::Lock()

	{

	__PRINT(_L("--->FsNotificationManager::Lock()"));

	iChainLock.Wait();

	}

void FsNotificationManager::Unlock()

	{

	__PRINT(_L("<---FsNotificationManager::Unlock()"));

	iChainLock.Signal();

	}

//Get the notification type based on the TFsMessage function

void CFsNotificationInfo::NotificationType(TInt aFunction,TNotificationType& aNotificationType)

	{

	__PRINT(_L("CFsNotificationInfo::NotificationType"));

	switch(aFunction)

		{

		case EFsFileWrite:

		case EFsFileWriteDirty:

		case EFsFileSetSize:

			{

			aNotificationType = TFsNotification::EFileChange;

			break;

			}

		case EFsRename:

		case EFsFileRename:

		case EFsReplace:

			{

			aNotificationType = TFsNotification::ERename;

			break;

			}

		case EFsMkDir:

		case EFsFileCreate:

		case EFsFileReplace:

			{

			aNotificationType = TFsNotification::ECreate;

			break;

			}

		case EFsFileSetAtt:

		case EFsFileSet:

		case EFsSetEntry:

			{

			aNotificationType = TFsNotification::EAttribute;

			break;

			}

		case EFsDelete:

		case EFsRmDir:

			{

			aNotificationType = TFsNotification::EDelete;

			break;

			}

		case EFsSetVolume:

			{

			aNotificationType = TFsNotification::EVolumeName;

			break;

			}

		case EFsSetDriveName:

			{

			aNotificationType = TFsNotification::EDriveName;

			break;

			}

		case EFsDismountFileSystem:

		case EFsMountFileSystem:

		case EFsFormatNext:

		case EFsRawDiskWrite:

		case EFsMountFileSystemScan:

			{

			aNotificationType = TFsNotification::EMediaChange;

			break;

			}

		default:

			{

			aNotificationType = (TFsNotification::TFsNotificationType)0;

			break;

			}

		}

	}

//=====CFsNotificationBlock============================

// Uses CFsPool

CFsNotificationBlock* CFsNotificationBlock::New()

	{

	return new CFsNotificationBlock();

	}

CFsNotificationBlock::CFsNotificationBlock()

	{

	}

CFsNotificationBlock::~CFsNotificationBlock()

	{

	//Nothing to do here

	}

TAny* CFsNotificationBlock::Data()

	{

	return (TAny*)&iData;

	}

TBool CFsNotifyRequest::ValidateNotification(TInt aNotificationSize, TInt& aServerTail)

	{

	__PRINT(_L("CFsNotifyRequest::ValidateNotification"));

	//RDebug::Print(_L("CFsNotifyRequest::ValidateNotification - iServerTail=%d, aServerTail=%d, iClientTail=%d,iClientHead=%d, aNotificationSize=%d"),iServerTail,aServerTail,iClientTail,iClientHead,aNotificationSize);

	//

	//Start Validation

	//

	TBool overflow = EFalse;

	//Check that we have not filled the buffer

    if (aServerTail == iClientHead)

        {

        // Buffer is empty when Client Tail = Client Head

        if (iClientHead != iClientTail)

        	{

			overflow = ETrue;

            return overflow;            

			}

        }

	//Work out remaining size taking account of whether the end position is

	//before or after the overflow position.

	TInt remainingSize = (iClientHead > aServerTail)

			? iClientHead - aServerTail 

			: iClientBufferSize - (aServerTail - iClientHead);

    TInt reservedSize = aNotificationSize;

    // + Save additional space for OVERFLOW

    reservedSize += KNotificationHeaderSize;

	//