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

//

#if !defined(__BM_DEFS_H__)

#define __BM_DEFS_H__

#include <cfmsgs.h>

#include "bindmgr.h"

#include <cflog.h>

/**

@file

@internalComponent

*/

__CFLOG_STMT(_LIT8(KLogSubSysRS,"RootServer");) // subsystem name

_LIT(KBindMgrPanic, "BindMgr");

enum TBindMgrPanics

	{

	EBadState,

	EDiscoveryRespOutOfSequence,

	EModuleRefMissing,

	EMsgQueueFault,

	EUnsupportedCFMessage

	};

class CCommsChannelSendQueue : public CActive

/** This class adds an input buffer to a comms framework CFChannel using

an array to store unsent messages.

*/

	{

public:

	static CCommsChannelSendQueue* NewL(RCFChannel& aChannel);

	~CCommsChannelSendQueue();

	TInt Send(const TCFMessage& aMsg);

	TInt ReserveSpace();

protected:

	void RunL();

	void DoCancel();

private:

	CCommsChannelSendQueue(RCFChannel& aChannel);

private:

	RArray<TCFMessage> iMsgQueue;

	RCFChannel& iChannel;

	};

class CTask;

class CModule : public CActive

/** Manages the state of a CPM or comms-server and handles the asynchronous

message queueuing.

*/

	{

public:

	static CModule* NewL(MBindManagerNotify *aNotifier,

						 const TCFModuleNameF &aModule,

						 TransactionId &aTransactionId,

						 const RCFChannel::TMsgQueues& aInputQueues,

						 const RCFChannel::TMsgQueues& aOutputQueues);

	~CModule();

	void SendL(const TCFMessage &aMessage);

	void DoDiscoverL(TUint &aTaskId);

	TBool CheckDiscoveryMsgFinishedL( const TCFMessage &aMessage );

	TBool GetBindTaskL(const RCFChannel::TMsgQueues& aInputQueues,

					   const RCFChannel::TMsgQueues& aOutputQueues,

					   const TCFSubModuleAddress &aSubModule1,

					   const TCFSubModuleAddress &aSubModule2,

					   const TCFBindType aType,

					   CTask*& aTask);

	TBool GetUnbindTaskL(const TCFSubModuleAddress& aSubModule1,

						 const TCFSubModuleAddress& aSubModule2,

						 const TBool aPeerIsDead,

						 CTask*& aTask);

	void DoStartTaskL(CTask* aTask);

	void DoShutdownL();

	void EndTask(const TUint &aTaskId, const TInt aStatus);

	void EndAllTasks(const TInt aStatus);

	TInt EnumerateSubModules(const TInt& aPosition, TCFSubModuleNameF& aSubModuleName);

	TInt NumSubModules() const;

	TBool HasSubModule(const TCFSubModuleNameF &aSubModule) const;

	TInt ReserveSpaceInSendQueue();

	const TCFSubModuleAddress &SubModuleNameRefL(const TCFSubModuleAddress &aSubModule);

	const TCFModuleNameF& Name() const;

	const TBool& Initialising() const;

	void SetInitialising(const TBool aInitialising);

	void Dequeue();

public:

	TDblQueLink iLink;

protected:

	virtual void DoCancel();

	virtual void RunL();

private:

	CModule(MBindManagerNotify *aNotifier,

			TransactionId& aTransactionId,

			const TCFModuleNameF &aModule);

	void ConstructL(const RCFChannel::TMsgQueues& aInputQueues,

					const RCFChannel::TMsgQueues& aOutputQueues);

	TUint GetNextTransactionId();

private:

	MBindManagerNotify *iNotifier;

	TCFModuleNameF iName;

	TBool iInitialising;

	RCFChannel iRecvChannel;

	RCFChannel iSendChannel;

    TDblQue<CTask> iTaskList;

	CCommsChannelSendQueue *iSendQueue;

	TCFSubModuleNameF* iDiscoveryArray;

	RArray<TCFSubModuleNameF> iSubModuleNames;

	RArray<TCFSubModuleAddress> iSubModuleAddrs;

	TransactionId &iTransactionId;

	};

class CBindInfo : public CBase

/** Stores details about an individual binding between two modules, including

the binding state and any errors associated with it.

*/

	{

public:

	static CBindInfo* NewL(const TRSBindType aType,

						   const TCFSubModuleAddress& aSubModule1,

						   const TCFSubModuleAddress& aSubModule2,

						   TInt aChannel1Length, TInt aChannel2Length);

	void ConstructL(TInt aChannel1Length, TInt aChannel2Length);

	void Dequeue();

	const RCFChannel& Channel1() const;

	const RCFChannel& Channel2() const;

	CBindManager::TBindingInfo& Info();

	~CBindInfo();

	void TaskCompleted(const CTask &aTask, const TInt aStatus);

	const TCFSubModuleAddress& SubModuleAddr1() const;

	const TCFSubModuleAddress& SubModuleAddr2() const;

	const TRSBindType& BindType() const;

	CBindManager::TBMBindState State1() const;

	CBindManager::TBMBindState State2() const;

	void SetState1(const CBindManager::TBMBindState aState);

	void SetState2(const CBindManager::TBMBindState aState);

	TInt Result1() const;

	TInt Result2() const;

	void SetResult1(const TInt aResult);

	void SetResult2(const TInt aResult);

public:

	TDblQueLink iLink;

private:

	CBindInfo(const TRSBindType aType,

			  const TCFSubModuleAddress& aSubModule1,

			  const TCFSubModuleAddress& aSubModule2);

private:

	class TSubModuleDetails

		{

		public:

			TSubModuleDetails(const TCFSubModuleAddress& aSubModule);

			const TCFSubModuleAddress iSubModule;

			CBindManager::TBMBindState iState;

			TInt iResult;

		};

	TRSBindType iType;

	TSubModuleDetails iSubModule1;

	TSubModuleDetails iSubModule2;

	RCFChannel iChannel1;

	RCFChannel iChannel2;

	};

class CTask : public CBase

/** Holds details about an individual message exchange with a server or CPM.

*/

	{

public:

	static CTask* NewL(const TCFMessage &aMessage, const TUint aTaskId = 0);

	TUint TaskId() const;

	const TCFMessage& Message() const;

	TBool CheckIfSame(TCFMessage &aMessage) const;

	TBool NeedReply() const;

	TBool ReplyMatches(const TCFMessage &aMessage) const;

	void Dequeue();

	~CTask();

	static TBool GetMsgReturnCode(const TCFMessage &aMessage, TInt &aStatus);

public:

	TDblQueLink iLink;

	enum { ENoReplyExpected = 0xFFFFFFFF };

private:

	CTask(const TCFMessage &aMessage, TUint aTaskId);

private:

	TInt iTaskId;

	TCFMessage iMessage;

	};

class MBMNotifyTimerShot

/** Abstract mixin interface class defining an up-call interface for a timer

expiry

*/

    {

public:

	virtual void ModuleTimerShot()=0;

    };

class CJobTimeout : public CTimer

/** Simple active object class providing timeout functionality to CJob

*/

    {

public:

    static CJobTimeout* NewL(MBMNotifyTimerShot* aNotifier);

protected:

    void RunL();

private:

    CJobTimeout(MBMNotifyTimerShot* aNotifier);

    MBMNotifyTimerShot* iNotifier;

    };

class CJob : public CBase, public MBMNotifyTimerShot

/** Manages an asynchronous call from the rootserver into bindmanager, including

monitoring a list of individual tasks associated with the job, and dealing

with a timeout if a task fails to complete

*/

	{

public:

    static CJob* NewL(TRequestStatus& iRsStatus, MBindManagerNotify *aBindManager);

	virtual void ModuleTimerShot();

	~CJob();

	void Dequeue();

	void AddTaskL(TUint aTaskId, const TCFModuleNameF &aModule);

	void StartTimeout(TUint aMicroseconds);

	void TaskCompleted(const TCFModuleNameF &aModuleName, const TUint aTaskId,

					   const TInt aStatus);

	TBool HasStatus(const TRequestStatus& aRsStatus) const;

	void Cancel();

public:

	TDblQueLink iLink;

private:

	CJob(TRequestStatus& aRsStatus, MBindManagerNotify *aBindManager);

	void ConstructL();

private:

	TRequestStatus& iRsStatus;	// as received from rootserver

	MBindManagerNotify *iBindManager;

	TInt iCompletionCode;

	TBool iCancelled;

	CJobTimeout *iTimeout;

	class TTaskData

		{

	public:

		TTaskData(TUint aTaskId, const TCFModuleNameF &aModule) :

			iTaskId(aTaskId),

			iModule(aModule)

				{

				}

	public:

		TUint iTaskId;

		const TCFModuleNameF &iModule;

		};

    RArray<TTaskData> iTaskDataList;

	};

#endif // __BM_DEFS_H__