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

//

/**

 @file

 @internalComponent

*/

#if !defined(__BINDMGR_H__)

#define __BINDMGR_H__

#include <cfshared.h>

#include <commschan.h>

using namespace CommsFW;

#include <rscommon.h>

using namespace RootServer;

#include <cfshared.h>

#include <cfmsgs.h>

// Uncomment this line to enable absurdly detailed logging

#define RS_DETLOG __CFLOG_VAR

#ifndef RS_DETLOG

#define RS_DETLOG(s)

#endif

// general bind manager constants

/** Defines the default number of elements in the sub-module array passed to a

server or CPM in a Discovery request.

 */

const TUint KDefaultSubmoduleArraySize = 4;

/** The time given to servers and CPMs to respond to messages before a job times

out and an error is reported to the binding manager client.

 */

const TUint KJobTimeoutMicroseconds = 60000000;

// forward declarations

class CModule;

class CJob;

class CBindInfo;

class CTask;

class MRootServerNotify;

class MBindManagerNotify

/** Mixin abstract interface class providing the up-call interfaces into the

BindManager from its internal components.

 */

    {

public:

    virtual void TaskCompleted(CModule &aModule,

                               const CTask &aTask,

                               TInt aStatus)=0;

    virtual void ReceivedMessage(const TCFModuleNameF& aModule,

                                 const TCFMessage& aNewMsg)=0;

    virtual void JobTimedOut(const TCFModuleNameF &aModuleName,

                             const TUint aTaskId)=0;

    };

class TransactionId

/** Generates ID numbers for messages that expect a responce message.

 */

    {

public:

    TransactionId(): iId(0x10000)

        {

        }

    TId GetId()

        {

        return (TId) ((iId++)? iId: 1);

        }

private:

    TInt iId;

    };

class CPersistentSubModuleAddressCon;

class CPersistentSubModuleAddress: public CBase

/* represents a submodule address intended to be made persistent as long as at least one client

 still references it */

    {

public:

    CPersistentSubModuleAddress(const TCFSubModuleAddress& aSubAddr,CPersistentSubModuleAddressCon* aContainerRef);

    // aContainerRef - the container that will store this object

    static CPersistentSubModuleAddress* NewL(const TCFSubModuleAddress& aSubAddr, CPersistentSubModuleAddressCon* aContainerRef);

    inline TCFSubModuleAddress& SubAddrRef();

    inline void Open();

    void Close(TInt aIndex = -1);

private:

    TCFSubModuleAddress iSubAddr;

    CPersistentSubModuleAddressCon* iContainerRef; // needed so that we can remove ourselves during Close op if this is called from cleanup stack unwind

    TInt iAccessCount;      //< Reference counting on this module addr. If it reaches 0 this object will be destroyed.

    };

class CPersistentSubModuleAddressCon : public CBase

/* Container to persist the moduleAddrs held within a module that may be lost on module (thread) death but

 possibly still required post-mortem. In particular, module name strings used by bind manager.

 */

    {

public:

    friend class CPersistentSubModuleAddress; // so their Close can remove items

    static CPersistentSubModuleAddressCon* NewL();

    ~CPersistentSubModuleAddressCon();

    TCFSubModuleAddress& SetOrRetrieveNameLC(const TCFSubModuleAddress& aRef);

    void Remove(const TCFSubModuleAddress& aRef);

private:

    RPointerArray<CPersistentSubModuleAddress> iPersistentModuleAddresses;

    };

class CBindManager : public CBase, public MBindManagerNotify

    {

/** Main singleton class providing Bind Manager functionality to the rootserver. This

class handles bind and unbind messaging through comms framework queues

and interfaces with the RootServer using asynch TReqestStatus objects.

 */

public:

    // NOTE: the relative ordering of the TBMBindState enums is relied upon by code

    enum TBMBindState

        {

        EBindInProgress,

        EBindError,

        EBound,

        EUnbindInProgress,

        EUnbindError,

        EUnbound    // NOTE: code relies upon this being the final value

        };

    class TBindingInfo

        {

    public:

        TRSBindType iType;

        TCFSubModuleAddress iSubModuleAddr1;

        TCFSubModuleAddress iSubModuleAddr2;

        TBMBindState iSubModuleState1;

        TBMBindState iSubModuleState2;

        TInt iSubModuleResult1;

        TInt iSubModuleResult2;

        };

    typedef RArray<TBindingInfo> RBindingInfoArray;

    static CBindManager* NewL(MRootServerNotify& aRootServerNotifier);

    void CreateModuleL(TRequestStatus& aStatus,

                       const TCFModuleNameF& aModule,

                       const RCFChannel::TMsgQueues& aInputQueues,

                       const RCFChannel::TMsgQueues& aOutputQueues);

    void UnbindAllAndShutDownL(TRequestStatus& aStatus,

                                        const TCFModuleNameF& aModule, TCFShutdownType aType);

    void ModuleEndedL(const TCFModuleNameF& aModule);

    TInt Cancel(TRequestStatus& aStatus);

    TInt EnumerateSubModules(const TCFModuleNameF& aModuleName, TInt aPosition, TCFSubModuleNameF& aName);

    TInt NumSubModules( const TCFModuleNameF& aName, TInt& aNumSubs );

    virtual ~CBindManager();

    virtual void TaskCompleted(CModule &aModule,

                               const CTask &aTask,

                               TInt aStatus);

    virtual void ReceivedMessage(const TCFModuleNameF& aModule,

                                 const TCFMessage& aNewMsg);

    virtual void JobTimedOut(const TCFModuleNameF &aModuleName,

                             const TUint aTaskId);

    void SendL( const TCFModuleNameF& aModule, const RMessage2& aMessage );

	void BindSubmodulesL(TRequestStatus& aStatus,

						 const TRSBindType aType,

						 const TCFSubModuleAddress& aUpperSubmodule,

						 const TCFSubModuleAddress& aLowerSubmodule,

						 TInt aForwardQLength,

						 TInt aReverseQLength);

	void UnbindSubmodulesL(TRequestStatus& aStatus,

								 	const TCFSubModuleAddress& aUpperSubmodule,

								 	const TCFSubModuleAddress& aLowerSubmodule);

	void UnbindAlreadyDeadL(TRequestStatus& aStatus,

									 const TCFModuleNameF& aModule);

	TInt EnumerateBindings(const TCFSubModuleAddress& aSubModule, TBool aRestart, TBindingInfo& aInfo);

private:

    CBindManager();

    CModule* GetModulePtrL(const TCFModuleNameF& aModule);

    CModule* GetModulePtrL(const TCFSubModuleAddress& aSubModuleAddr);

    void UnbindAllModuleL(TRequestStatus& aStatus,

                          const TCFModuleNameF& aModule,

                          const TBool aModuleIsDead,

                          CJob*& pJob);

    static void ConvertRSBindType(const TRSBindType aType,

                                  TCFBindType& aUpperBindType,

                                  TCFBindType& aLowerBindType);

	CBindInfo* FindBindInfo(const TCFSubModuleAddress& aUpperSubmodule,

							const TCFSubModuleAddress& aLowerSubmodule);

    void ConstructL();

private:

    MRootServerNotify *iNotify;

    TDblQue<CModule> iModuleList;

    TDblQue<CJob> iJobList;

    TDblQue<CBindInfo> iBindList;

    TransactionId iTransactionId;

    /** Index for enumeration of bindings */

    TInt iEnumBindingsIdx;

    CPersistentSubModuleAddressCon* iModuleNameStor; // persist module names for messages since the msgs may outlive modules

    };

inline TCFSubModuleAddress& CPersistentSubModuleAddress::SubAddrRef()

    {

    return iSubAddr;

    }

inline void CPersistentSubModuleAddress::Open()

    {

    ++iAccessCount;

    }

#endif // __BINDMGR_H__