// 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.h
// 
//

#include "sf_std.h"
#include "sf_pool.h"
#include "e32hashtab.h" 
#include "cl_notification.h"
#include "f32notification.h"

#ifndef SF_NOTIFIER_H
#define SF_NOTIFIER_H

/**
 * Number of notifications in TFsNotificationType that the client can set
 * @internalTechnology
 */
const TInt KNumRegisterableFilters = 8; 

/*
 * This determines the size of the CFsPool.
 * Until we have read/write locks there is no point in this being more than 1.
 * 
 * @internalTechnology
 */
const TInt KNotificationPoolSize = 1;


/**
 * A CFsNotificationPathFilter is a simple class containing two HBufCs of the target to be notified about:
 * 1 for the drive and path
 * 1 for the filename
 *  
 *  A CFsNotificationPathFilter has a 1 to Many relationship with TFsNotificationTypeFilter
 *  
 * @internalTechnology
 */
class CFsNotificationPathFilter
	{
public:
	static CFsNotificationPathFilter* NewL(const TDesC& aPath, const TDesC& aFilename, TInt aDriveNum);
	~CFsNotificationPathFilter();
private:
	void ConstructL(const TDesC& aPath, const TDesC& aFilename, TInt aDriveNum);
	CFsNotificationPathFilter();
public:
	TInt iDriveNum;
	HBufC* iPath;
	HBufC* iFilename;
	};

/**
 * A TFsNotificationTypeFilter is a class which contains a pointer to the associated path to monitor
 * and the type of notification.
 * 
 * @internalTechnology
 */
class TFsNotificationTypeFilter
	{
public:
	CFsNotificationPathFilter* iPathFilter;
	TFsNotification::TFsNotificationType iNotificationType; 
	//As we are storing filters in filter-specific
	//arrays then iNotificationType is potentially redundant.
	};

//These typedefs are to appease the compiler as it does not like
//nested templated arguments.
 /**
  *  @internalTechnology
  */
typedef RArray<TFsNotificationTypeFilter> TFsNotificationTypeArray;
/**
 * @internalTechnology
 */
typedef RArray<TFsNotificationTypeArray> TFsNotificationTypeDriveArray;

class CFsNotificationBlock; //forward decl.

/**
 * CFsNotifyRequest is a file-server side object representation of an RFsNotify sub-session.   
 * 
 * @internalTechnology
 */
NONSHARABLE_CLASS(CFsNotifyRequest) : public CFsObject
	{
public:
	
	/*
	 * Active means that the client is waiting for the first notification to be sent
	 * The status then changes to Outstanding when further notifications are sent to the buffer
	 * If the server overflows when in state EOutstanding then we move to state EOutstandingOverflow.
	 * From EOutstandingOverflow after the next call to RequestNotifications from the client, we must move to state EInactive.
	 * If we do not overflow then when RequestNotifications is called we can move back to state EActive.
	 * EInactive is when there are no notifications outstanding and request notifications hasn't been called. 
	 */
	enum TNotifyRequestStatus
		{
		EActive,				//Server waiting for a notification (filters added, RequestNotifications called)
		EOutstanding,			//Server waiting for client to call RequestNotifications, has notification(s) to send.
		EOutstandingOverflow,	//Server waiting for client to call RequestNotifications, has notification(s) to send, buffer has overflowed.
		EInactive				//Server waiting for RequestNotification, no notifications outstanding 
		};
	
	static CFsNotifyRequest* NewL();
	virtual ~CFsNotifyRequest();
	
	/*
	 * Returns the RArray<TFsNotificationFilter> for an index
	 * as returned from CFsNotificationInfo::TypeToIndex()
	 */
	TFsNotificationTypeArray* FilterTypeList(TInt aDrive,TInt aIndex);
	
	//Removes all filters from iFilterList
	TInt RemoveFilters();

	//Add single filter to this request
	TInt AddFilterL(CFsNotificationPathFilter* aFilter, TUint aMask);

	//Sets filter as active/inactive
	void SetActive(TNotifyRequestStatus aValue);
	
	/**
	 *Get the status of this request.
	 *@See TNotifyRequestStatus 
	 */ 
	TNotifyRequestStatus ActiveStatus();
	
	/*
	 * Completes and frees notification request
	 * 
	 * @param aIsCancel is used to determine whether 
	 * to write back to the client or not when aReason != KErrNone.
	 * 
	 * In the case of closing the subsession you shouldn't write back to the client.
	 */
	void CompleteClientRequest(TInt aReason,TBool aIsCancel=EFalse);

	//RfsNotify::RequestNotifications has been called
	TInt SetClientMessage(const RMessage2& aClientMsg);

	/* 
	 * Called from FsNotificationManager::HandleChange(),
	 * this function packages the data in to a CFsNotificationBlock in preperation for 
	 * notification of this operation to the client.
	 * 
	 * Calling of this function means that we are notifying about this operation. (all checks passed)
	 */
	TInt NotifyChange(CFsNotificationInfo* aRequest, CFsNotificationBlock& aBlock);
		
	/*
	 * This function performs the IPC to the client's buffer.
	 */
	TInt SynchroniseBuffer(CFsNotificationBlock& aBlock,TInt aServerTail, TInt aNotificationSize);
	
	//Closing this notification
	void CloseNotification();

	//Simple getter
	TInt ClientMsgHandle();
	
	//Platsec needs to check against the path with a message of the *receiving* client. 
	const RMessage2& BufferMessage();
	
private:
	CFsNotifyRequest();
	void ConstructL();
	
	//Check whether there is room for a new notification in the client's buffer
	TBool ValidateNotification(TInt aNotificationSize, TInt& aServerTail);
	
	/*
	 * The iTailSemaphore is used so that many CFsNotificationBlocks can
	 * be processed concurrently.
	 * This lock ensures that the iServerTail is safe.
	 */
	 //ToDo:  This should be a ReadWriteLock
	RFastLock iTailSemaphore;
	
	/*
	 * The iClientSyncLock is a Read/Write style lock whereby it is 
	 * set up with the value of KNotificationPoolSize.
	 * When a block is allocated it calls wait on this lock.
	 * 
	 * This lock is to ensure that all of the currently processing blocks are
	 * written before the client is updated.
	 * 
	 * i.e. if two blocks are being processed concurrently and the second 
	 * block is written we need to wait until the first one is also written
	 * before the client receives the updated tail.
	 */
	//ToDo: This should be a ReadWriteLock
	RFastLock iClientSyncLock;
	

	/*
	 * HashMap<DriveNumber, TFsNotificationTypeDriveArray>
	 * HashMap<DriveNumber, RArray<TFsNotificationTypeArray>>
	 * HashMap<DriveNumber, RArray<RArray<TFsNotificationTypeFilter>>>
	 * 
	 * Each value of iDrivesTypesFiltersMap is of type TFsNotificationTypeDriveArray 
	 * associated with a particular drive.
	 * 
	 * Each index of the TFsNotificationTypeDriveArray is a TFsNotificationTypeArray
	 */
	RHashMap<TInt,TFsNotificationTypeDriveArray> iDrivesTypesFiltersMap;
		
	RMessage2 iBufferMsg; //To update buffer
	RMessage2 iClientMsg; //client notification request
	
	CSessionFs* iSession; //Session associated with this request (TFsSessionDisconnect::DoRequestL)
	
	TNotifyRequestStatus iNotifyRequestStatus;	//Current status of this request
	
	//The following 3 variables must be aligned when modified.
	TInt iClientHead;	//Offset where the client should start reading from.
						//If the server writes past this offset we must overflow the client.
	
	TInt iClientTail;	//The end of the client's accessible range.
	
	TInt iServerTail;	//The end of the server's accessible range.
						//Overflow occurs if iServerTail becomes more than iClientHead.
	
	TInt iClientBufferSize;		//Buffer size is word-aligned.
	
	friend class TFsNotificationBuffer;	//For access to iClientBufferSize and iBufferMsg
	friend class TFsNotificationRequest;//For access to iClientBufferSize
	friend class FsNotificationManager; //For access to iSession
	friend class TFsNotificationOpen; //For access to iSession
	friend class TFsNotificationRemove; //For access to iDrivesTypesFiltersMap
	};

/**
 * A CFsNotificationBlock is a chunk of memory which is used to represent a notification
 * such that a single IPC can be performed from server to client.
 * 
 * CFsNotificationBlocks are stored in a CFsPool<CFsNotificationBlock>. 
 * 
 *@internalTechnology
 */
class CFsNotificationBlock
	{
public:
	static CFsNotificationBlock* New();
	~CFsNotificationBlock();
	TAny* Data();
private:
	CFsNotificationBlock();
	TText8 iData[KMinNotificationBufferSize];
	};

/**
 * The FsNotificationManager is a static object
 * 
 *@internalTechnology
 */
class FsNotificationManager
	{
public:
	//New notification request from client
	static void AddNotificationRequestL(CFsNotifyRequest* aNotificationRequest);

	//Notification request cancel
	static void RemoveNotificationRequest(CFsNotifyRequest* aNotificationRequest);
	//Notification request cancel (session closed)
	static void RemoveNotificationRequest(CSessionFs* aSession);

	/* A change has occurred represented by this request.
	 * Work out which CFsNotifyRequests are interested
	 * (if any) and call CFsNotifyRequest::NotifyChange.
	 */
	static void HandleChange(CFsNotificationInfo& aRequest);
	
	//Initialise iNotifyRequests and iStaticNotification
	static void OpenL();
	static TBool IsInitialised();
	
	/*
	 * On CFsNotifyRequest closing, Close is called if this is the last request being removed.
	 * This removes all of the managers private data.
	 */
	static void Close();

	/*
	 * Calls SetFilterRegister for every valid notification set in aMask.
	 */
	static void SetFilterRegisterMask(TUint aMask,TBool aAdd);
	
	/*
	 * Adds or Removes to the count of filters set up for a particular type
	 * This is a global count such that if there are no fiters for a particular type 
	 * HandleChange doesn't need to do any iteration for that type.
	 */
	static void SetFilterRegister(TUint aFilter, TBool aAdd, TInt aCount = 1);
	/*
	 * Get the number of registers filters set up on a particular type.
	 * @param aIndex the TFsNotificationType's index as determined from CFsNotificationInfo::TypeToIndex
	 */
	static TInt& FilterRegister(TInt aIndex);

	/*
	 * Returns the number of CFsNotifyRequests set up
	 */
	static TInt Count();
	
	/*
	 * Lock the iChainLock (currently not a ReadWriteLock)
	 */
	static void Lock();
	
	/*
	 * Unlock iChainLock
	 */
	static void Unlock();

private:
  
    /*
     * @internalTechnology
	 * Used by DoMatchFilter and DoHandleChange to control the flow of 
	 * loop execution.
     */
    enum TFsNotificationFilterMatch
        {
        EDifferent  = 0x00, //Operation and Filters do not match.
        EMatch      = 0x01, //Operation and Filters do match.
        EContinue   = 0x02  //Data caged directory - Do not notify.
        };
    
    /*
     * Checks whether aOperation matches the filter name and/or path set in aFilter. 
     */
    static TFsNotificationFilterMatch DoMatchFilter(const RMessage2& aMessage, const TDesC& aOperationName,CFsNotificationPathFilter& aFilter);
    
	/*
	 * Iterates filters for a particular drive.
	 * Called from HandleChange
	 */
	static void DoHandleChange(TFsNotificationTypeArray* aFilterTypeArray, TInt& aSeenFilter, CFsNotificationInfo& aNotificationInfo, CFsNotifyRequest* aNotifyRequest);
	
	/*
	 * Stores the CFsNotifyRequests
	 */
	static CFsObjectCon* iNotifyRequests;
	
	//As we are doing notifications 'in-place' which is multi-threaded
	//we need to have locking to protect iNotifyRequests.
	//ToDo: ReadWriteLock
	static RFastLock iChainLock;
	
	/*
	 * Global register per filter type. 
	 * Keeps a count of the number of filters set up for a particular type
	 * (NB: EMediaChange is reported regardless of filters set)
	 */
	static TInt iFilterRegister[KNumRegisterableFilters];
	
	/*
	 * This is a pool of blocks which are server-side versions of TFsNotification.
	 * They are used so that we can have a single IPC from server to client.
	 * 
	 * it will also be used for coalescing changes.
	 */
	static CFsPool<CFsNotificationBlock>* iPool;
	
	friend class CFsNotifyRequest;
	friend class RequestAllocator;
	friend class TFsNotificationSubClose;
	};


#endif /* SF_NOTIFIER_H */