// Copyright (c) 2008-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:
//
/**
@internalComponent
*/
#ifndef CPTPIPCONNECTION_H_
#define CPTPIPCONNECTION_H_
#include <mtp/tmtptyperequest.h>
#include <mtp/tmtptypeevent.h>
#include <mtp/mtpdataproviderapitypes.h>
#include <mtp/tmtptypenull.h>
#include "mmtpconnectionmgr.h"
#include "mmtpconnectionprotocol.h"
#include "mmtptransportconnection.h"
#include "ptpipdatatypes.h"
#include "cptpipgenericcontainer.h"
#include "cptpipdatacontainer.h"
#include "tptpiprequestpayload.h"
#include "tptpipresponsepayload.h"
#include "tptpipstartdatapayload.h"
#include "tptpipinitevtack.h"
#include "mtpdebug.h"
#include "ptpipprotocolconstants.h"
class CPTPIPCommandHandler;
class CPTPIPEventHandler;
class MMTPConnectionProtocol;
class MMTPConnectionMgr;
/**
Implements the MTP USB device class connection protocol and transport layer
interface.
This is the class implementing the main API functions exposed to the framework layer
for exchange of data with the transport layer.
It also has the communication protocol which exposes the SPI / observer functions
exposed by the framework layer , which is used by the transport to communicate with
the framework.
It implements a state machine which keeps track of whether we are sending data ,
expecting response etc.
The error handling strategy is as follows:
If unexpected data is received on the event channel , we close the connection.
If unexpected data is received on the command channel the we close the connection.
If the internal state is invalid, then a panic is raised.
Any errors received, are passed up to the MTP fw, except for TCP disconnection
which is converted to KErrAbort.
@internalComponent
*/
class CPTPIPConnection : public CActive,
public MMTPTransportConnection
{
public :
enum TConnectionState
{
EIdle = 0x00000000,
EInitialising = 0x00000001,
EInitialisationComplete = 0x00000002,
EStartListening = 0x00000003,
EDataSendInProgress = 0x00000004,
EDataSendFinished = 0x00000007,
ECancelled = 0x00000008
};
enum TCancelState
{
ECancelNotReceived = 0x00000000,
ECancelCmdReceived = 0x10000001,
ECancelCmdHandleInProgress= 0x10000002,
ECancelCmdHandled = 0x10000003,
ECancelEvtReceived = 0x20000001,
ECancelEvtHandled = 0x20000003,
ECancelChannel = 0xF0000000
};
static CPTPIPConnection* NewL(MMTPConnectionMgr& aConnectionMgr);
~CPTPIPConnection();
public : // from MMTPTransportConnection
virtual void BindL(MMTPConnectionProtocol& aProtocol) ;
virtual MMTPConnectionProtocol& BoundProtocolLayer();
virtual void CloseConnection() ;
virtual void ReceiveDataL(MMTPType& aData, const TMTPTypeRequest& aRequest) ;
virtual void ReceiveDataCancelL(const TMTPTypeRequest& aRequest) ;
virtual void SendDataL(const MMTPType& aData, const TMTPTypeRequest& aRequest) ;
virtual void SendDataCancelL(const TMTPTypeRequest& aRequest) ;
virtual void SendEventL(const TMTPTypeEvent& aEvent) ;
virtual void SendResponseL(const TMTPTypeResponse& aResponse, const TMTPTypeRequest& aRequest) ;
virtual void TransactionCompleteL(const TMTPTypeRequest& aRequest) ;
virtual void Unbind(MMTPConnectionProtocol& aProtocol) ;
virtual TAny* GetExtendedInterface(TUid aInterfaceUid) ;
virtual TUint GetImplementationUid();
public : //from CActive
void DoCancel();
void RunL();
TInt RunError(TInt aError);
public : // Other functions
void GetCancelPayload();
void CompleteSelf(TInt aCompletionCode);
void SetConnectionState(TConnectionState);
// Receiving functions:
void ReceiveCommandChannelCompleteL(TInt aError, MMTPType& aSource);
void ReceiveEventCompleteL(TInt aError, MMTPType& aSource);
void ReceiveCommandCompleteL(TInt aError);
void ReceiveCommandDataL(MMTPType& aData) ;
void ReceiveCommandDataCompleteL(TInt aError);
// Sending funtions
void SendCommandChannelCompleteL(TInt aError, const MMTPType& aSource);
void SendResponseCompleteL(TInt aError, MMTPType& aSource);
void SendEventCompleteL(TInt aError, const MMTPType& aSource);
void SendStartDataPacketL();
void SendDataPacketL();
void SendCommandCompleteL(TInt aError);
void SendCommandDataCompleteL(TInt aError);
CPTPIPGenericContainer* CommandContainer();
CPTPIPGenericContainer* EventContainer();
CPTPIPDataContainer* DataContainer();
TUint32 ValidateAndSetCommandPayloadL();
TUint32 ValidateAndSetEventPayloadL();
TUint32 ValidateDataPacketL();
TMTPTransactionPhase TransactionPhase() const;
void HandleError(TInt aError);
void SetDataTypeInDataContainerL(TPTPIPPacketTypeCode aType);
TBool ConnectionOpen() const;
private:
CPTPIPConnection(MMTPConnectionMgr& aConnectionMgr);
void ConstructL();
void TransferSocketsL();
void InitiateCommandRequestPhaseL();
void InitiateEventRequestPhaseL();
void SendInitAckL();
void DoSendDataL();
void DoReceiveDataL();
// Cancel handling functions
void HandleEventCancelL();
void HandleCommandCancelL(TUint32 aTransId);
void HandleCommandCancelCompleteL();
void SendCancelToFrameworkL(TUint32 aTransId);
void SendCancelResponseL(TUint32 aTransId);
void HandleCancelDuringSendL();
void SetTransactionPhase(TMTPTransactionPhase);
TBool ValidateTransactionPhase(TMTPTransactionPhase aExpectedTransactionState);
TBool HandleTCPError(TInt& aError);
void StopConnection();
void SetNULLPacketL();
private: // Owned
/**
The current state of the MTP transaction, ( request, response, data phase)
*/
TMTPTransactionPhase iTransactionState;
/**
Current state of the Connection, ( whether its initialisting, transferring data, listening)
*/
TInt iState;
/**
Flag, which is turned on when the cancel operation is received on the command channel.
*/
TCancelState iCancelOnCommandState;
/**
Flag, which is turned on when the cancel operation is received on the event channel.
*/
TCancelState iCancelOnEventState;
/**
During the sending of data this keeps track of the total data to send
*/
TUint64 iTotalDataLen;
/**
Command handler to send the data via the command socket.
*/
CPTPIPCommandHandler* iCommandHandler;
/**
EventHandler to send the data via the event socket.
*/
CPTPIPEventHandler* iEventHandler;
// Command Container & payloads //
/**
Command Container, its payload can be request, response, start data or cancel.
*/
CPTPIPGenericContainer* iPTPIPCommandContainer;
/**
Command Request Paramenter Payload
4 - data phase
2 - op code
4 - tran id
20 - 5 params
*/
TPTPIPTypeRequestPayload iPTPIPRequestPayload;
/**
CommandData Response Parameter Payload
2 - res code
4 tran id
20 - 5 params
*/
TPTPIPTypeResponsePayload iPTPIPResponsePayload;
/**
StartData parameter payload
4 - tran id
8 - total length
*/
TPTPIPTypeStartDataPayload iPTPIPStartDataPayload;
/**
Cancel data Parameter payload
4 trans id
*/
TMTPTypeInt32 iPTPIPCommandCancelPayload;
// Event Container & payloads //
/**
Event Container, its payload can be event, cancel or probe (ie no payload)
*/
CPTPIPGenericContainer* iPTPIPEventContainer;
/**
Event Payload
2 - res code
4 tran id
20 - 5 params
*/
TPTPIPTypeResponsePayload iPTPIPEventPayload;
/**
Event Payload
*/
TMTPTypeUint32 iPTPIPEventCancelPayload;
// Data Container ( payload comes from mtp f/w) //
/**
4 - tran id
? - payload, given by the framework.
*/
CPTPIPDataContainer* iPTPIPDataContainer;
/**
The current active MTP SessionID, set while sending response to open session.
*/
TUint32 iMTPSessionId;
/**
The active MTP operation request dataset buffer.
*/
TMTPTypeRequest iMTPRequest;
/**
The MTP event dataset buffer.
*/
TMTPTypeEvent iMTPEvent;
/**
The total amount of data expected, this is filled from the ptpip start data packet.
*/
TUint64 iTotalRecvData;
/**
The data receved so far.
*/
TUint64 iRecvData;
/**
Data sink for consuming data during error recovery from
a failed ItoR transaction.
*/
TMTPTypeNull iNull;
/**
Buffer for reading discarded data into.
*/
RBuf8 iNullBuffer;
/**
FLOGGER debug trace member variable.
*/
__FLOG_DECLARATION_MEMBER;
private: // Not Owned
/**
The MTP connection manager.
*/
MMTPConnectionMgr* iConnectionMgr;
/**
The MTP connection protocol layer binding.
This is the SPI/ observer - transport uses it to communicate to the MTP framework.
*/
MMTPConnectionProtocol* iProtocolLayer;
};
#endif /*CPTPIPCONNECTION_H_*/