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

#define CMTPDATAPROVIDER_H

/**

@file

@internalComponent

*/

#include "rmtpframework.h"

#include <e32base.h>

#include <mtp/mmtpdataproviderframework.h>

#include <mtp/mtpdataproviderapitypes.h>

#include <mtp/tmtptypeevent.h>

#include <mtp/tmtptyperequest.h>

#include <mtp/tmtptyperesponse.h>

#include "mtpdebug.h"

class CMTPConnection;

class CMTPDataProviderPlugin;

class CMTPDataProviderConfig;

class MMTPDataProvider;

class MMTPDataProviderConfig;

class MTPFrameworkConfig;

class MMTPObjectMgr;

class MMTPTransactionProxy;

class MMTPDataCodeGenerator;

/**

Implements the API portion of the API/SPI interface pair by which MTP framework 

and data provider plug-ins interact. A unique CMTPDataProvider instance is 

created and bound to each CMTPDataProviderPlugin instance that is loaded, and 

functions on its behalf to:

    a)	Process MTP operational and media object data to and from the MTP 

        framework, and;

    b)	Manage MTP transaction protocol state transitions to ensure that the 

        MTP transaction state remains valid under both normal and error 

        recovery processing conditions.

@internalTechnology

*/

class CMTPDataProvider : 

    public CActive, 

    public MMTPDataProviderFramework

    {

public:

    /**

    The enumeration state bit flags.

    */

    enum TEnumerationStates

        {

        EUnenumerated               = 0x00000000,

        EObjectsEnumerationState    = 0x0000000F,

        EObjectsEnumerating         = 0x00000003,

        EObjectsEnumerated          = 0x00000001,

        EStoragesEnumerationState   = 0x000000F0,

        EStoragesEnumerating        = 0x00000030,

        EStoragesEnumerated         = 0x00000010,

        EEnumerated                 = (EStoragesEnumerated | EObjectsEnumerated)

        };

public:

	static CMTPDataProvider* NewL(TUint aId, TUid aImplementationUid, CMTPDataProviderConfig* aConfig);

	static CMTPDataProvider* NewLC(TUint aId, TUid aImplementationUid, CMTPDataProviderConfig* aConfig);

	~CMTPDataProvider();

	void ExecuteEventL(const TMTPTypeEvent& aEvent, MMTPConnection& aConnection);

	void ExecuteRequestL(const TMTPTypeRequest& aRequest, MMTPConnection& aConnection);

	IMPORT_C void ExecuteProxyRequestL(const TMTPTypeRequest& aRequest, MMTPConnection& aConnection, MMTPTransactionProxy& aProxy);

    void EnumerateObjectsL(TUint32 aStorageId);

    void EnumerateStoragesL();

    IMPORT_C TUint EnumerationState() const;

    IMPORT_C TUid ImplementationUid() const;

	IMPORT_C CMTPDataProviderPlugin& Plugin() const;

    IMPORT_C TBool Supported(TMTPSupportCategory aCategory, TUint aCode) const;

    IMPORT_C const RArray<TUint>& SupportedCodes(TMTPSupportCategory aCategory) const;

    void SetDataProviderId(TUint aId);

    static TInt LinearOrderUid(const TUid* aUid, const CMTPDataProvider& aObject);

    static TInt LinearOrderUid(const CMTPDataProvider& aL, const CMTPDataProvider& aR);

	static TInt LinearOrderDPId(const TUint* aDPId, const CMTPDataProvider& aObject);

    static TInt LinearOrderDPId(const CMTPDataProvider& aL, const CMTPDataProvider& aR);

    static TInt LinearOrderEnumerationPhase(const CMTPDataProvider& aL, const CMTPDataProvider& aR);

public: // From MMTPDataProviderFramework

    TUint DataProviderId() const;

    TMTPOperationalMode Mode() const;

    void ReceiveDataL(MMTPType& aData, const TMTPTypeRequest& aRequest, MMTPConnection& aConnection);

    void SendDataL(const MMTPType& aData, const TMTPTypeRequest& aRequest, MMTPConnection& aConnection);

    void SendEventL(const TMTPTypeEvent& aEvent, MMTPConnection& aConnection);

    void SendEventL(const TMTPTypeEvent& aEvent);

    void SendResponseL(const TMTPTypeResponse& aResponse, const TMTPTypeRequest& aRequest, MMTPConnection& aConnection);

    void TransactionCompleteL(const TMTPTypeRequest& aRequest, MMTPConnection& aConnection);

    void RouteRequestRegisterL(const TMTPTypeRequest& aRequest, MMTPConnection& aConnection);

    void RouteRequestUnregisterL(const TMTPTypeRequest& aRequest, MMTPConnection& aConnection);

    void ObjectEnumerationCompleteL(TUint32 aStorageId);

    void StorageEnumerationCompleteL();

    const MMTPDataProviderConfig& DataProviderConfig() const;

    const MMTPFrameworkConfig& FrameworkConfig() const;

	MMTPObjectMgr& ObjectMgr() const;

    MMTPReferenceMgr& ReferenceMgr() const;

    MMTPStorageMgr& StorageMgr() const;

    RFs& Fs() const;

    MMTPDataCodeGenerator& DataCodeGenerator() const;

    void NotifyFrameworkL( TMTPNotificationToFramework aNotification, const TAny* aParams );

private: // From CActive

	void DoCancel();

	void RunL();

	TInt RunError(TInt aError);

private:

   	CMTPDataProvider(TUint aId, TUid aImplementationUid, CMTPDataProviderConfig* aConfig);

    void ConstructL();

	void Schedule();

  	void SendErrorResponseL(TInt aError);

private:

    /**

    */

    class CSupportedCodes : public CBase

        {

    public:

        static CSupportedCodes* NewLC(TMTPSupportCategory aCategory, MMTPDataProvider& aDp);

        virtual ~CSupportedCodes();

        const RArray<TUint>& Codes() const;

        TBool Supported(TUint aCode) const;

    private:

        CSupportedCodes();

        void ConstructL(TMTPSupportCategory aCategory, MMTPDataProvider& aDp);

    private:

        RArray<TUint> iCodes;

        };

private: // Owned

    /**

    FLOGGER debug trace member variable.

    */

    __FLOG_DECLARATION_MEMBER_MUTABLE;

    /**

    The data provider configurability parameter data.

    */

	CMTPDataProviderConfig*         iConfig;

    /**

    The construction completed flag. This is used to indicate that ownership 

    of passed objects has been assumed.

    */

    TBool                           iConstructed;

	/**

	The transaction phase of the currently active operation.

	*/

    TMTPTransactionPhase            iCurrentTransactionPhase;

    /**

    The enumeration state.

    */

	TUint                           iEnumerationState;

	/**

	The error recovery flag, indicating that an error occurred while processing

	a request. 

	*/

	TInt                            iErrorRecovery;

    /** 

    The data provider identifier.

    */

	TInt                            iId;

	/**

	The data provider implementation plug-in.

	*/

	CMTPDataProviderPlugin*         iImplementation;

	/**

	The data provider implementation UID.

	*/

	TUid                            iImplementationUid;

	/**

	The transaction phase of the currently active transaction proxy.

	*/

    TMTPTransactionPhase            iProxyTransactionPhase;

    /**

    The MTP response dataset buffer.

    */

	TMTPTypeResponse		        iResponse;

    /**

    The framework singletons.

    */

	RMTPFramework                   iSingletons;

    /** 

    The data provider's support categories table.

    */

    RPointerArray<CSupportedCodes>  iSupported;

    /** Indicates whether iTimer is active. */

    TBool							iTimerActive;

    /*****

	 * Added timer to delay request handling until storage/object enumeration has finished

	 */ 	

	RTimer iTimer;

private: // Not owned

	/**

	The MTP connection on which the currently active operation is being 

	processed.

	*/

	CMTPConnection*                 iCurrentConnection;

    /**

    The MTP request dataset buffer.

    */

	const TMTPTypeRequest*          iCurrentRequest;

	/**

	The currently active transaction proxy.

	*/

	MMTPTransactionProxy*           iProxy;

    };

#endif // CMTPDATAPROVIDER_H