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

*/

#ifndef CMTPCONNECTION_H

#define CMTPCONNECTION_H

#include <e32property.h>

#include <e32base.h>

#include <mtp/mmtpconnection.h>

#include <mtp/mtpdataproviderapitypes.h>

#include <mtp/tmtptypeevent.h>

#include <mtp/tmtptyperesponse.h>

#include <mtp/rmtpclient.h>

#include "mmtpconnectionprotocol.h"

#include "rmtpframework.h"

#include "mtpdebug.h"

#include "mtpbuildoptions.hrh"

#include "mtpdebug.h"

class CMTPSession;

class MMTPTransportConnection;

class TRequestStatus;

class TMTPTypeRequest;

class TMTPTypeFlatBase;

#ifdef MTP_CAPTURE_TEST_DATA

class CMTPRequestLogger;

#endif

/** 

Implements the connection level portion of the MTP communication model and 

associated transport layer protocol binding. This class Implements the API 

portion (@see MMTPConnectionProtocol) of the transport layer API/SPI interface 

pair by which MTP framework and transport protocol connections 

(@see MMTPTransportConnection) interact. A unique @see CMTPConnection instance 

is created and bound to each @see MMTPTransportConnection instance that is 

loaded. 

It also implements the data provider layer MTP connection interface 

(@see MMTPConnection) which represents the virtual circuit between data provider 

and the transport layer.

@internalComponent

*/

class CMTPConnection : 

    public CBase,

    public MMTPConnection, 

    public MMTPConnectionProtocol

    {

private:

	class CMTPEventLink :

		public CBase

		{

	public:

		CMTPEventLink(const TMTPTypeEvent& aEvent);

	public:

		TSglQueLink		iLink;

		TMTPTypeEvent	iEvent;		

		};

public:

    static CMTPConnection* NewLC(TUint aConnectionId, MMTPTransportConnection& aTransportConnection);

    ~CMTPConnection();

    void ReceiveDataL(MMTPType& aData, const TMTPTypeRequest& aRequest, TRequestStatus& aStatus);

    void SendDataL(const MMTPType& aData, const TMTPTypeRequest& aRequest, TRequestStatus& aStatus);

    void SendEventL(const TMTPTypeEvent& aEvent);

    void SendResponseL(const TMTPTypeResponse& aResponse, const TMTPTypeRequest& aRequest, TRequestStatus& aStatus);

    IMPORT_C void SessionClosedL(TUint32 aSessionMTPId);

    IMPORT_C void SessionOpenedL(TUint32 aSessionMTPId);

    IMPORT_C TInt GetDataReceiveResult() const;

    TBool ConnectionSuspended();

    void ConnectionResumedL(MMTPTransportConnection& aTransportConnection);

    void TransactionCompleteL(const TMTPTypeRequest& aRequest);

public: // From MMTPConnection & MMTPConnectionProtocol

    TUint ConnectionId() const;

public: // From MMTPConnection

    TUint SessionCount() const;

    TBool SessionWithMTPIdExists(TUint32 aMTPId) const;

    MMTPSession& SessionWithMTPIdL(TUint32 aMTPId) const;

    TBool SessionWithUniqueIdExists(TUint32 aUniqueId) const;

    MMTPSession& SessionWithUniqueIdL(TUint32 aUniqueId) const;

    TMTPTransactionPhase TransactionPhaseL(TUint32 aMTPSessionId) const;

	void DisconnectionNotifyL();

private: // From MMTPConnectionProtocol

    void ReceivedEventL(const TMTPTypeEvent& aEvent);

    void ReceivedRequestL(const TMTPTypeRequest& aRequest);

    void ReceiveDataCompleteL(TInt aErr, const MMTPType& aData, const TMTPTypeRequest& aRequest);

    void SendDataCompleteL(TInt aErr, const MMTPType& aData, const TMTPTypeRequest& aRequest);

    void SendEventCompleteL(TInt aErr, const TMTPTypeEvent& aEvent);

    void SendResponseCompleteL(TInt aErr, const TMTPTypeResponse& aResponse, const TMTPTypeRequest& aRequest);

    void Unbind(MMTPTransportConnection& aConnection);

private:

    CMTPConnection(TUint aConnectionId, MMTPTransportConnection& aTransportConnection);

    void ConstructL();

    void InitiateMTPErrorRecoveryL(const TMTPTypeRequest& aRequest, TUint16 aResponseCode);

    void MTPErrorRecoveryComplete();

    void UnrecoverableMTPError();

    void InitiateTransactionCancelL(TInt aSessionIdx);

    TUint ActiveSessions() const;

    void CloseAllSessions();

    void CloseSession(TUint aIdx);

    void CompleteCloseConnection();

    CMTPSession& SessionL(const TMTPTypeFlatBase& aDataset, TInt aSessionIdElementNo) const;

    static TInt SessionOrder(const TUint32* aL, const CMTPSession& aR);

    static TInt SessionOrder(const CMTPSession& aL, const CMTPSession& aR);

    void SetState(TUint aState);

    TUint State() const;

    TBool ValidFrameworkRequest(CMTPSession* aSession, TUint aValidStates, TRequestStatus* aStatus);

    void RemoveEventsForSession(TUint32 aMTPId);

    void EnqueueEvent(CMTPEventLink* aLink);

    void DequeueEvent(CMTPEventLink* aLink);

/**

  * This method define and attach the property for publishing connection state 

  *  events.

  */

    void DefineConnStatePropertyL(); 

/**

  * This method is to publish various connection state.

  */

    void PublishConnState(TMTPConnStateType aConnState);	

    void ValidateAndPublishConnState(CMTPSession& aSession, TInt aState);

private: // Owned

    enum TStates

        {

        EStateUnknown,

        EStateOpen,

        EStateErrorRecovery,

        EStateErrorShutdown,

        EStateShutdown

        };

    TUint                       iConnectionId;

    RPointerArray<CMTPSession>  iSessions;

    TUint                       iState;

    RMTPFramework               iSingletons;

    TAny*                       iExtendedInterface;

    TMTPTypeResponse 			iResponse;

    TSglQue<CMTPEventLink>		iEventQ;

    TInt 						iPendingEventCount;   

    TInt 						iDataReceiveResult;

    /**

    FLOGGER debug trace member variable.

    */

    __FLOG_DECLARATION_MEMBER_MUTABLE;

private: // Not owned

    MMTPTransportConnection*    iTransportConnection;

    //For publishing the connection state.

    RProperty iProperty; 

    /**

    Special build, capture request, data phase and responses to disk.

    */

#ifdef MTP_CAPTURE_TEST_DATA 

    CMTPRequestLogger*          iRequestLogger;

#endif

    };

#endif // CMTPCONNECTION_H