// Copyright (c) 1997-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:
// generic backup server
// 
//

#if !defined(__BAKSRV_H__)
#define __BAKSRV_H__

#include <e32std.h>
#include <e32base.h>
#include <babackup.h>
#include <badesca.h>
#include <bsul/clientmessage.h>

//Forward declarations
class BSUL::CClientMessage;

/**
@internalTechnology
*/
const TInt KBakServMajorVN      =0;
const TInt KBakServMinorVN      =1;
const TInt KBakServBuildVN      =1;
const TInt KBakServMessageSlots	=4;		// no async messages to backup server

/**
@internalTechnology
*/
enum TBaBackupServPanic
	{
	EReqAlreadyOutstanding	=0,
	EReqDoesNotExist		=1,
	EBadFileName			=2,
	ELocksAlreadyReleased	=3,
	EBufferOverflow			=4,
	ENoEventToFetch			=5,
	EHandleNotClosed		=6,
	};

class CBaServBackupSession;

/**
@internalTechnology
*/
enum TCompletionType
	{
	ECompleteSync	=0x00,
	ECompleteAsync	=0x01,
	};


/**
@internalTechnology
*/
class CBaServBackupScheduler : public CActiveScheduler
	{
public:
	IMPORT_C CBaServBackupScheduler();
	inline static CBaServBackupScheduler* Current();
	IMPORT_C void SetErrorHandler(CBaServBackupSession* aErrorHandler);
	IMPORT_C ~CBaServBackupScheduler();
public: // from CActiveScheduler
	IMPORT_C virtual void Error(TInt aError) const;
private:
	CBaServBackupSession* iErrorHandler;
	};

/**
@internalTechnology
*/
NONSHARABLE_CLASS(CBaServBackupMessageQueue) : public CBase
	{
public:
	static CBaServBackupMessageQueue* NewL();
	~CBaServBackupMessageQueue();
	void AddItemL(const TDesC& aFileName,MBackupObserver::TFileLockFlags aFlag);
	void AddItem(const TDesC& aFileName);
	TBool IsEmpty() const;
	void GetHead(TDes& aFileName,MBackupObserver::TFileLockFlags& aFlag) const;
	void RemoveHead();
	void RemoveItem(const TDesC& aFileName);
private:
	TInt HeadIndex() const;
private:
	enum TOperation
		{
		ENoOp		=-1,
		ETakeLock	=0,
		};
	class TQueueItem
		{
	public:
		inline TQueueItem(HBufC* aFileName,TInt aOperation);
	public:
		HBufC* iFileName;
		TInt iOperation;
		};
private:
	RArray<TQueueItem> iQueue;
	};
	 
class CBaBackupServer;

/**
@internalTechnology
*/
class CBaServBackupSession : public CSession2

	{
public:
	class TClosedFile
		{
	public:
		inline TBool operator==(const TClosedFile& aClosedFile) const;
	public:
		TFileName iDocName;
		TUid iUid;
		};
	enum TLockType
		{ENull,ERelease,ETake,EPendingReleaseReadOnly,EPendingReleaseNoAccess,EPendingTake};
	class TFileLock
		{
	public:
		RMessagePtr2 iMessagePtr;
		TLockType iRequest;
		HBufC* iFileName;
		};
public:
	class CReRegistrationTimer;
public:
	IMPORT_C ~CBaServBackupSession();
	inline CBaBackupServer* BackupServer() const;
public:
	IMPORT_C virtual void HandleError(TInt aError);
protected: // from CSession
	IMPORT_C virtual void ServiceL(const RMessage2& aMessage);
	IMPORT_C virtual void CreateL();
protected:
	IMPORT_C virtual void ConstructL();
	IMPORT_C virtual TCompletionType CloseAllFilesL(const RMessage2& aMessage);
	IMPORT_C TCompletionType DoCloseAllFilesL(const RMessage2& aMessage);
	IMPORT_C virtual void RestartAll();
protected:
	IMPORT_C CBaServBackupSession();
	inline CArrayFix<TClosedFile>* ClosedFiles() const;
	inline void SetClosedFiles(CArrayFix<TClosedFile>* aClosedFiles);
	inline TInt UniqueClientId() const;
public:
	static CBaServBackupSession* NewL();
	void SignalReleaseAllFileLocksL(MBackupObserver::TFileLockFlags aFlag);
	void SignalRetakeAllFileLocks();
	void SignalReleaseFileLockL(MBackupObserver::TFileLockFlags aFlag,const TDesC& aFileName);
	void SignalRetakeFileLocks(const TDesC& aFileName);
	void SignalBackupOperation(const TBackupOperationAttributes& aBackupOperationAttributes);
private:
	static void CleanupCloseAllFiles(TAny* aPtr);
	void HandleEventReadyL();
	void GetEventL();
	void RestartFileL();
	void NotifyLockChangeL();
	void NotifyLockChangeCancelL();
	void GetFileNameL(TDes& aFileName);
	void BackupOperationEventReadyL();
	void GetBackupOperationEventL(const RMessagePtr2& aPtr);
	void GetBackupOperationStateL();
	void DoRestartAll();
	void NotifyBackupOperationL();
	void DoServiceL(TCompletionType& aCompleteType);
	void CloseFileL();
	void StopNotifications();
private:
	TUint32 iUniqueClientId;
	CBaServBackupMessageQueue* iMessageQueue;
	RMessagePtr2 iNotificationPullMsg;
	CArrayFix<TClosedFile>* iClosedFiles;
	CDesCArray* iFileLockObservers;
	CDesCArray* iReleasedFiles;
	RMessagePtr2 iBackupOperationMessagePtr;
	TBackupOperationAttributes iBackupOperationAttributes;
	TBool iBackupOperationObserverPresent;
	CReRegistrationTimer* iReRegistrationTimer; /* File lock re-registration timer */
	BSUL::CClientMessage* iClientMessage;
	
	};

class CShutdownServer;

/**
@internalTechnology
*/
class CBaBackupServerExt : public CBase  
	{
public:
	TUint32 iCachedBusyClientId;
	TUint32 iUniqueBusyClientId;
	};

//
// CBaBackupServer
//


/**
@internalTechnology
*/
class CBaBackupServer : public CServer2

	{
public:
	class CBaServCloseAllOperationTimer;
public:
	IMPORT_C static CBaBackupServer* NewL();
	IMPORT_C ~CBaBackupServer();
	IMPORT_C void SetBusy(TUint32 aUniqueClientId);
	IMPORT_C TBool IsClientBusy(TUint32 aUniqueClientId) const;
	IMPORT_C void SignalBackupOperation(const TBackupOperationAttributes& aBackupOperationAttributes);
	IMPORT_C TBool HaveAllCloseAllFilesClientsReRegistered();
	IMPORT_C void SetCloseAllOperationRunningState(TBool aRunning);
public:
	inline TBool IsBackupOperationRunning() const;
	inline void SetBackupOperationRunning(TBool aBackupOperationRunning);
public:
	IMPORT_C virtual void CloseAllFilesL(MBackupObserver::TFileLockFlags aFlag);
	IMPORT_C virtual void RestartAll();
	IMPORT_C virtual void ConstructL();
	IMPORT_C virtual void CompleteClosingFiles(CArrayFix<CBaServBackupSession::TClosedFile>* aClosedFiles);
	IMPORT_C virtual TBool IsOtherClientBusy(TUint32 aUniqueClientId) const;
public:
	void CloseFileL(MBackupObserver::TFileLockFlags aFlag,const TDesC& aFileName);
	void RestartFile(const TDesC& aFileName);
	void AddSession();
	void DropSession();
	void IncrementRegisteredFilesCount();
	void DecrementRegisteredFilesCount(TInt aNumberFiles = 1);
	void IncrementFilesReRegistrationCount();
	void StartCloseAllFilesOperationTimer(const RMessagePtr2& aPtr);
	TBool IsCloseAllOperationRunning();
public: // from CServer
	IMPORT_C TInt RunError(TInt aError);
protected:
	IMPORT_C CBaBackupServer(TInt aPriority);
protected: // from CServer
	IMPORT_C CSession2* NewSessionL(const TVersion &aVersion, const RMessage2& aMessage) const;
private:
	CBaBackupServerExt* iExtension;
	TBool iBackupOperationRunning;
	TInt iSessionCount;
	CShutdownServer* iShutdown;
	TInt16 iRegisteredFilesCount;
	TInt16 iSessionLockReRegistrationCount; /* Number of file lock sessions currently registered */
	CBaServCloseAllOperationTimer* iCloseAllFilesOperationTimer; /* Base file lock re-registration timer */
	TBool iCloseAllOperationRunning; /* Indicates that a CloseAll operation is in progress */
	};

inline CBaServBackupScheduler* CBaServBackupScheduler::Current()
	{ // static
	return static_cast<CBaServBackupScheduler*>(CActiveScheduler::Current());
	}

inline CBaBackupServer* CBaServBackupSession::BackupServer() const
	{
	return static_cast<CBaBackupServer*>(const_cast<CServer2*>(CSession2::Server()));
	}

inline CArrayFix<CBaServBackupSession::TClosedFile>* CBaServBackupSession::ClosedFiles() const
	{
	return iClosedFiles;
	}

inline void CBaServBackupSession::SetClosedFiles(CArrayFix<TClosedFile>* aClosedFiles)
	{
	if(!iClosedFiles)
		{
		iClosedFiles=aClosedFiles;
		}
	}

inline TInt CBaServBackupSession::UniqueClientId() const
	{
	return iUniqueClientId;
	}

inline TBool CBaServBackupSession::TClosedFile::operator==(const TClosedFile& aClosedFile) const
	{
	return iDocName==aClosedFile.iDocName && iUid==aClosedFile.iUid;
	}

inline TBool CBaBackupServer::IsBackupOperationRunning() const
	{
	return iBackupOperationRunning;
	}

inline void CBaBackupServer::SetBackupOperationRunning(TBool aBackupOperationRunning)
	{
	iBackupOperationRunning = aBackupOperationRunning;
	}

#endif