// SensibleServer.h

// 

// Copyright (c) 2006 - 2010 Accenture. All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the "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:

// Accenture - Initial contribution

//

#ifndef SENSIBLESERVER_H

#define SENSIBLESERVER_H

#include <e32base.h>

#include "cliserv.h"

#include <f32file.h>

#include <gdi.h>

#include <basched.h>

#include "SensibleCompat.h"

class CCallbackContext;

class CSensibleSession;

class CFilteringScheduler;

void PanicClient(const RMessage& aMessage, TInt TMyPanic);

extern void CleanupPanicPushL();

class CShutdown : public CTimer

	{

public:

	inline CShutdown();

	inline void ConstructL();

	inline void Start(TInt aDelay);

private:

	void RunL();

	};

class CSensibleServer : public CServerBase

	{

public:

	void AddSession();

	void DropSession();

	inline CFilteringScheduler* Scheduler();

	CSensibleServer();

	~CSensibleServer();

	virtual void ConstructL();

	// Some functions that call into the filtering scheduler

	// NOTE: These functions cannot be used at the same time as queuing a callback that requires a result, nor can they be nested (you'll get a panic)

	//void BlockAllAOsExceptServerRequests();

	void BlockRequestsFrom(CActive* aActive1, CActive* aActive2=NULL);

	void StopBlocking();

protected:

	#ifdef __HIDE_IPC_V1__

	CSession2* NewSessionL(const TVersion& aVersion, const RMessage2& aMessage) const;

	#else

	CSessionBase* NewSessionL(const TVersion& aVersion) const;

	#endif

	TInt RunError(TInt aError);

	virtual TInt TransientServerShutdownTime() const; // Return 0 to never shutdown

private:

	TInt iSessionCount;

	CShutdown iShutdown;

	CFilteringScheduler* iScheduler;

	CActiveScheduler* iOldScheduler;

	};

class CSensibleSession : public CSessionBase

	{

public:

	CSensibleSession();

	#ifndef __HIDE_IPC_V1__

	void CreateL(const CServer& aServer);

	#endif

	void CreateL();

	void QueueCallbackL(CCallbackContext* aContext); // This completes a callback immediately if possible, otherwise queues it. Used for callbacks that MUST be delivered.

	TBool DispatchCallback(TServerCallback& aCallback); // This completes a callback immediately if possible, otherwise returns EFalse. Used for notify-style callbacks. The callback cannot have a context.

	void CompleteNextCallback();

protected:

	virtual TBool DoServiceL(const RMessage& aMessage); // return EFalse if aMessage wasn't handled

	~CSensibleSession();

private:

	inline CSensibleServer& Server();

	void ServiceL(const RMessage& aMessage);

//	inline TBool ReceivePending() const;

private:

	TSglQue<CCallbackContext> iCallbackQ;

	RMessage iCallbackNotifier;

	TBool iCallbackPending;

	TBool iWaitingForCallbackResult;

	};

enum TCallbackContextFlags

	{

	EResultHBufC8 = 2,

	EResultHBufC16 = 4,

	EResultIsLeaveCode = 8,

	EActive = 16,

	EBlockServer = 32,

	};

class TCallbackWriter

	{

public:

	TCallbackWriter(TServerCallback& aCallback, HBufC8** aContext);

	// If any of the AddLs leave, they will delete aContext if it has been created

	void AddL(TInt aInt);

	void AddL(TUint aInt);

	void AddL(TPoint aPoint);

	void AddL(TSize aSize);

	void AddL(TRgb aRgb);

	void AddL(TRect aRect);

	void AddL(const TDesC16& aDesc);

	void AddL(const TDesC8& aDesc);

private:

	void AddL(const TDesC8& aData, char* aType);

private:

	TServerCallback& iCallback;

	HBufC8** iContext;

	TPtr8 iBuf;

	TBool iInContext;

	};

class CCallbackContext : public CBase

	{

public:

	union TResult

		{

		HBufC8** s;

		HBufC16** l;

		TDes8* pkg;

		TInt integer;

		};

public:

	CCallbackContext(TCallbackCode aCode);

	~CCallbackContext();

	void SetFlags(TInt aFlags);

	TBool Flag(TInt aFlags) const; // All bits of aFlags must be set to return true

	void ClearFlags(TInt aFlags);

	TBool CallbackRequiresResult() const;

	TBool CallbackHasContext() const;

	//void SetContext(HBufC8* aContext); // Takes ownership and clears flag EContextHBufC16

	//void SetContext(HBufC16* aContext); // Takes ownership and sets flag EContextHBufC16

	TCallbackWriter Writer();

	void SetResult(TDes8& aPkg); // Sets appropriate flags

	void SetResult(HBufC8*& aResult); // Sets appropriate flags

	void SetResult(HBufC16*& aResult); // Sets appropriate flags

	//void SetResult(TInt& aResult); // Sets appropriate flags

	HBufC8* Context();

	TResult& Result();

	TServerCallback& Callback();

private:

	void AddContext(const TUint8* aPtr, TInt aSize, char* aType);

private:

	TInt iFlags; // bitwise OR of TCallbackContextFlags

	TServerCallback iCallback;

	HBufC8* iContext;

	TResult iResult;

public:

	TSglQueLink iLink;

	};

#endif