/*

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

*

*/

#ifndef CREQUESTPROCESSOR_H

#define CREQUESTPROCESSOR_H

#include <mtp/tmtptypenull.h>

#include <mtp/mtpdataproviderapitypes.h>

#include <mtp/mtpprotocolconstants.h>

#include <mtp/tmtptyperesponse.h>

// for derived processors

#include <mtp/mmtpdataproviderframework.h>

#include "crequestchecker.h"

class MMTPConnection;

class TMTPTypeRequest;

class MMTPDataProviderFramework;

class TMTPTypeEvent;

class CMTPObjectInfo;

const TInt KMmMtpRArrayGranularity = 2;

/**

* Defines a request processor interface

*/

class MMmRequestProcessor

    {

public:

    /**

    * Process a request from the initiator

    * @param aRequest The request to be processed

    * @param aPhase The transaction phase of the request

    * @return ETrue to signal that the processor object can be deleted, EFalse to keep the processor object

    */

    virtual TBool HandleRequestL( const TMTPTypeRequest& aRequest,

        TMTPTransactionPhase aPhase ) = 0;

    /**

    * Process an event from the initiator

    * @param aEvent The event to be processed

    */

    virtual void HandleEventL( const TMTPTypeEvent& aEvent ) = 0;

    /**

    * delete the request processor object

    */

    virtual void Release() = 0;

    /**

    * Check if the processor matches the request on the connection

    * @param aRequest The request to be checked

    * @param aConnection The connection from which the request comes

    * @return ETrue to indicate the processor can handle the request, otherwise, EFalse

    */

    virtual TBool Match( const TMTPTypeRequest& aRequest,

        MMTPConnection& aConnection ) const = 0;

    /**

    * Check if the processor matches the event on the connection

    * @param aEvent The event to be checked

    * @param aConnection The connection from which the event comes

    * @return ETrue to indicate the processor can handle the event, otherwise, EFalse

    */

    virtual TBool Match( const TMTPTypeEvent& aEvent,

        MMTPConnection& aConnection ) const = 0;

    /**

    * Get the request object which the processor is currently handling

    * @return the request object which the processor is currently handling

    */

    virtual const TMTPTypeRequest& Request() const = 0;

    /**

    * Get the connection object associated with the current request object

    * @return the connection object associated with the current request object

    */

    virtual MMTPConnection& Connection() const = 0;

    /*

    * Rollback when WMP closed and disconnect the USB cable,

    * during the transferring file

    */

    virtual void UsbDisconnect() = 0;

    /*

    * Get the session id associated with current request object

    * This interface was added to avoid the case that the data member iRequest

    * was sometimes invalid in session close phase, and getting session id from

    * request would cause panic

    * @return session id

    */

    virtual TUint32 SessionId() = 0;

    };

/**

* Defines a processor factory function pointer

*/

typedef MMmRequestProcessor* (*TMTPRequestProcessorCreateFunc)( MMTPDataProviderFramework& aFramework,

    MMTPConnection& aConnection );

/**

* Defines an entry which maps from operation code to the request processor

*/

typedef struct

    {

    TUint16 iOperationCode;

    TMTPRequestProcessorCreateFunc iCreateFunc;

    } TMTPRequestProcessorEntry;

/**

* Defines a generic request processor interface from which all processors derive

*/

class CRequestProcessor : public CActive, public MMmRequestProcessor

    {

protected:

    /**

    * Standard c++ constructor

    * @param aFramework   The data provider framework

    * @param aConnection  The connection from which the request comes

    * @param aElementCount Number of element in the request.

    * @param aElements    The element info data.

    * @return a pointer to the created request processor object

    */

    IMPORT_C CRequestProcessor( MMTPDataProviderFramework& aFramework,

        MMTPConnection& aConnection,

        TInt aElementCount,

        const TMTPRequestElementInfo* aElements );

    /**

    * Destructor

    */

    IMPORT_C virtual ~CRequestProcessor();

protected:

    // utility methods

    /**

    * Send a response to the initiator

    * @param aResponseCode The response code to send

    * @param aParamCount  The number of parameters

    * @param aParmas  The pointer to array of parameters

    */

    IMPORT_C void SendResponseL( TMTPResponseCode aResponseCode,

        TInt aParameterCount = 0,

        TUint32* aParams = NULL );

    /**

    * Signal to the framework that the current request transaction has completed

    */

    void CompleteRequestL();

    /**

    * Send data to the initiator

    * @param aData    The data to send

    */

    IMPORT_C void SendDataL( const MMTPType& aData );

    /**

    * Receive data from the initiator

    * @param aData    The data to receive

    */

    IMPORT_C void ReceiveDataL( MMTPType& aData );

protected:

    // from MMTPRequestProcessor

    /**

    * Handle the request

    * @param aRequest The request to be processed

    * @param aPhase   The current transaction phase of the request

    * @return ETrue if the transaction has completed, otherwise, EFalse

    */

    IMPORT_C TBool HandleRequestL( const TMTPTypeRequest& aRequest,

        TMTPTransactionPhase aPhase );

    /**

    * Handle the event

    * @param aEvent The event to be processed

    */

    IMPORT_C void HandleEventL( const TMTPTypeEvent& aEvent );

    /**

    * Relese (delete) this request processor

    */

    IMPORT_C void Release();

    /**

    * Check whether the processor can process the request

    * @param aRequest The request to be processed

    * @param aConnection The connection from which the request comes

    * @return ETrue if the processor can process the request, otherwise EFalse

    */

    IMPORT_C TBool Match( const TMTPTypeRequest& aRequest,

        MMTPConnection& aConnection ) const;

    /**

    * Check whether the processor can process the event

    * @param aEvent The event to be processed

    * @param aConnection The connection from which the request comes

    * @return ETrue if the processor can process the request, otherwise EFalse

    */

    IMPORT_C TBool Match( const TMTPTypeEvent& aEvent,

        MMTPConnection& aConnection ) const;

    /**

    * The current active request

    * @return A reference to the current request

    */

    IMPORT_C const TMTPTypeRequest& Request() const;

    /**

    * The connection from which the current request comes

    * @return A reference to the current connection

    */

    IMPORT_C MMTPConnection& Connection() const;

    /*

    * Rollback when WMP closed and disconnect the USB cable,

    * during the transferring file

    */

    IMPORT_C void UsbDisconnect();

    /*

    * Get the session id associated with current request object

    * This interface was added to avoid the case that the data member iRequest

    * was sometimes invalid in session close phase, and getting session id from

    * request would cause panic

    * @return session id

    */

    IMPORT_C TUint32 SessionId();

protected:

    // from CActive

    /**

    * part of active object framework, provide default implementation

    */

    IMPORT_C void RunL();

    /**

    * part of active object framework, provide default implementation

    */

    IMPORT_C void DoCancel();

    /**

    * part of active object framework, provide default implementation

    */

    IMPORT_C TInt RunError( TInt aError );

protected:

    // new virtuals

    /**

    * Handle the request phase of the current request

    * @return EFalse

    */

    IMPORT_C virtual TBool DoHandleRequestPhaseL();

    /**

    * Handle the receiving data phase of the current request

    * @return EFalse

    */

    IMPORT_C virtual TBool DoHandleDataIToRPhaseL();

    /**

    * Handle the sending data phase of the current request

    * @return EFalse

    */

    IMPORT_C virtual TBool DoHandleRToIPhaseL();

    /**

    * Handle the response phase of the current request

    * @return EFalse

    */

    IMPORT_C virtual TBool DoHandleResponsePhaseL();

    /**

    * Handle the completing phase of the current request

    * @return ETrue

    */

    IMPORT_C virtual TBool DoHandleCompletingPhaseL();

    /**

    * Check the current request

    * @return EMTPRespCodeOK if the reqeust is good, otherwise, one of the error response codes

    */

    IMPORT_C virtual TMTPResponseCode CheckRequestL();

    IMPORT_C virtual TBool HasDataphase() const;

    /**

    * service a request at request phase

    */

    virtual void ServiceL() = 0;

protected:

    /**

    * Set P&S Status to avoid MPX access conflict

    */

private:

    /**

    * retrieve the session id and transaction code from the current request

    */

    void ExtractSessionTransactionId();

protected:

    MMTPDataProviderFramework& iFramework;

    const TMTPTypeRequest* iRequest; //the pending requst object

    MMTPConnection& iConnection; //the connection from which the request comes

    TMTPTypeResponse iResponse; //the response object to send to the initiator

    TBool iCancelled; //indicates whether the data phase (send/receive) has been cancelled

    CRequestChecker* iRequestChecker; //a utility class providing generic request verification service

    TInt iElementCount; //number of verification elements used for request checker

    const TMTPRequestElementInfo* iElements; //pointer to an array of verification elements

    TUint32 iSessionId; //session id for the pending request

    TUint32 iTransactionCode; //transaction code for the pending request

private:

    TMTPResponseCode iResponseCode; // contains response from CheckRequestL call

    RBuf8 iNullBuffer; // buffer to receive data from discarded data phase

    TMTPTypeNull iNull;

    };

#endif // CREQUESTPROCESSOR_H