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

 	~CFsNotificationPathFilter();

 private:

 	void ConstructL(const TDesC& aPath, const TDesC& aFilename);

 	CFsNotificationPathFilter();

 public:

 	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 FsNotificationHelper::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)

 	 * 

 	 * aRequest can be NULL when the request doesn't come from the file server 

 	 * (such as when a media card is removed)

 	 */

 	TInt NotifyChange(CFsClientMessageRequest* aRequest, const TDesC& aName, TFsNotification::TFsNotificationType aNotificationType, 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();

 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;

 	/*

 	 * The iPathFilterList is an RPointerArray of CFsNotificationPathFilters.

 	 * 

 	 * These are normally only accessed via a TFsNotificationTypeFilter (via iDrivesTypesFiltersMap),

 	 * not via this array directly.

 	 */

 	RPointerArray<CFsNotificationPathFilter> iPathFilterList;

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

 	};

 /**

  * Helper class to get certain attributes from or about a particular operation to used in a notification

  * 

  * @internalTechnology

  */

 class FsNotificationHelper

 	{

 public:

 	static void NotificationType(TInt aFunction,TFsNotification::TFsNotificationType& aNotificationType);

 	static void PathName(CFsClientMessageRequest& aRequest, TDes& aName);

 	static void NewPathName(CFsClientMessageRequest& aRequest, TPtrC& aName);

 	static TInt NotificationSize(CFsClientMessageRequest& aRequest, TFsNotification::TFsNotificationType aNotificationType, const TDesC& aName);

 	static TInt TypeToIndex(TFsNotification::TFsNotificationType aType);

 	static TFsNotification::TFsNotificationType NotificationType(TInt& aIndex);

 	static TInt DriveNumber(const TPtrC& aPath);

 	static void Attributes(CFsClientMessageRequest& aRequest, TUint& aSet, TUint& aClear);

 	};

 /**

  * 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(CFsClientMessageRequest& aRequest);

 	/* A change has occurred represented by this request.

 	 * Work out which CFsNotifyRequests are interested

 	 * (if any) and call CFsNotifyRequest::NotifyChange.

 	 * 

 	 * This override is used directly when we want to force a particular notification type

 	 */

 	static void HandleChange(CFsClientMessageRequest& aRequest, TFsNotification::TFsNotificationType aType);

 	/* 

 	 * This override is used directly when we want to specify the current operation's name (src) and notification type.

 	 * 

 	 * aRequest can be NULL when the request doesn't come from the file server 

 	 * such as when a media card is removed, see LocalDrives::CompleteDriveNotifications

 	 * 

 	 * @See LocalDrives::CompleteDriveNotifications(TInt aDrive)

 	 */

 	static void HandleChange(CFsClientMessageRequest* aRequest, const TDesC& aOperationName, TFsNotification::TFsNotificationType aType);

 	//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 FsNotificationHelper::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(CFsClientMessageRequest* aRequest, const TDesC& aOperationName,CFsNotificationPathFilter& aFilter);

 	/*

 	 * Iterates filters for a particular drive.

 	 * Called from HandleChange

 	 */

 	static void DoHandleChange(TFsNotificationTypeArray* aFilterTypeArray, TInt& aSeenFilter, CFsClientMessageRequest* aRequest, CFsNotifyRequest* aNotifyRequest, const TDesC& aOperationName, TFsNotification::TFsNotificationType& aType);

 	/*

 	 * 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 */