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

//

#include <mtp/cmtpdataproviderplugin.h>

#include <mtp/mtpdataproviderconfig.hrh>

#include <mtp/mtpprotocolconstants.h>

#include <mtp/tmtptyperesponse.h> 

#include "cmtpsession.h"

#include "cmtpconnection.h"

#include "cmtpconnectionmgr.h"

#include "cmtpdataprovider.h"

#include "cmtpdataproviderconfig.h"

#include "cmtpframeworkconfig.h"

#include "cmtpobjectmgr.h"

#include "cmtpparserrouter.h"

#include "cmtpreferencemgr.h"

#include "cmtpstoragemgr.h"

#include "mmtptransactionproxy.h"

#include "rmtpframework.h"

#include "cdummydp.h"

#include "cmtpdatacodegenerator.h"

#include "mtpdebug.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmtpdataproviderTraces.h"

#endif

const TInt KWaitForEnumeration = 1000000 * 3;

#define KMTPDummyDataProvider             0x0000

/**

CMTPDataProvider factory method. 

@param aId The data provider identifier.

@param aUid The data provider implementation UID.

@param aConfig The data provider configurability parameter data. Ownership IS 

transfered.

@return A pointer to a new CMTPDataProvider instance. Ownership IS transfered.

@leave One of the system wide error codes if a processing failure occurs.

*/

CMTPDataProvider* CMTPDataProvider::NewL(TUint aId, TUid aUid, CMTPDataProviderConfig* aConfig)

    {

    CMTPDataProvider* self = CMTPDataProvider::NewLC(aId, aUid, aConfig);

    CleanupStack::Pop(self);

    return self;

    }

/**

CMTPDataProvider factory method. A pointer to the CMTPDataProvider instance is

placed on the cleanup stack.

@param aUid The data provider implementation UID.

@param aConfig The data provider configurability parameter data. Ownership IS 

transfered.

@return A pointer to a new CMTPDataProvider instance. Ownership IS transfered.

@leave One of the system wide error codes if a processing failure occurs.

*/ 

CMTPDataProvider* CMTPDataProvider::NewLC(TUint aId, TUid aUid, CMTPDataProviderConfig* aConfig)

    {

    CMTPDataProvider* self = new (ELeave) CMTPDataProvider(aId, aUid, aConfig);

    CleanupStack::PushL(self);

    self->ConstructL();    

    return self;

    }

/**

Destructor.

*/

CMTPDataProvider::~CMTPDataProvider()

    {

    OstTraceFunctionEntry0( CMTPDATAPROVIDER_CMTPDATAPROVIDER_DES_ENTRY );

    OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_CMTPDATAPROVIDER_DES, 

            "data provider %d ", iId);

    Cancel();

    iSupported.ResetAndDestroy();

    delete iImplementation;

    iSingletons.Close();

    // Only delete passed objects when fully constructed.

    if (iConstructed)

        {

        delete iConfig;

        }

	iTimer.Close();  

    OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_CMTPDATAPROVIDER_DES, 

            "data provider %d ", iId);	

    OstTraceFunctionExit0( CMTPDATAPROVIDER_CMTPDATAPROVIDER_EXIT );

    }

void CMTPDataProvider::ExecuteEventL(const TMTPTypeEvent& aEvent, MMTPConnection& aConnection)

    {   

    OstTraceFunctionEntry0( CMTPDATAPROVIDER_EXECUTEEVENTL_ENTRY );

    OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_EXECUTEEVENTL, 

            "data provider %d ", iId);

    __ASSERT_DEBUG(iImplementation, User::Invariant());

    if (iTimerActive && aEvent.Uint16(TMTPTypeEvent::EEventCode) == EMTPEventCodeCancelTransaction)

	    {

	    Cancel();

	    }

    // Pass this event notification directly to the plugin...

    // In reality we will only ever see one event canceltransaction.

    iImplementation->ProcessEventL(aEvent, aConnection);

    OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_EXECUTEEVENTL, 

            "data provider %d ", iId);        

    OstTraceFunctionExit0( CMTPDATAPROVIDER_EXECUTEEVENTL_EXIT );

    }

void CMTPDataProvider::ExecuteRequestL(const TMTPTypeRequest& aRequest, MMTPConnection& aConnection)

    {

    OstTraceFunctionEntry0( CMTPDATAPROVIDER_EXECUTEREQUESTL_ENTRY );

    OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_EXECUTEREQUESTL, 

            "data provider %d ", iId);

    __ASSERT_DEBUG(iImplementation, User::Invariant());

    iCurrentRequest = &aRequest;

    iCurrentConnection = &iSingletons.ConnectionMgr().ConnectionL(aConnection.ConnectionId());

    // Schedule data provider to process this request.  

    Schedule(); 

    OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_EXECUTEREQUESTL, 

            "data provider %d ", iId);    

    OstTraceFunctionExit0( CMTPDATAPROVIDER_EXECUTEREQUESTL_EXIT );

    }

EXPORT_C void CMTPDataProvider::ExecuteProxyRequestL(const TMTPTypeRequest& aRequest, MMTPConnection& aConnection, MMTPTransactionProxy& aProxy)

    {

    OstTraceFunctionEntry0( CMTPDATAPROVIDER_EXECUTEPROXYREQUESTL_ENTRY );

    OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_EXECUTEPROXYREQUESTL, 

            "data provider %d ", iId);    

    iProxy = &aProxy;

    iCurrentRequest    = &aRequest;

    iCurrentConnection = static_cast<CMTPConnection*>(&aConnection);

    Schedule();

    OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_EXECUTEPROXYREQUESTL, 

            "data provider %d ", iId);      

    OstTraceFunctionExit0( CMTPDATAPROVIDER_EXECUTEPROXYREQUESTL_EXIT );      

    }

void CMTPDataProvider::ExecutePendingRequestL()

    {

    OstTraceFunctionEntry0( CMTPDATAPROVIDER_EXECUTEPENDINGREQUESTL_ENTRY );

    if (iCurrentRequest != NULL && !IsActive())

        {

        Schedule();

        }

    OstTraceFunctionExit0( CMTPDATAPROVIDER_EXECUTEPENDINGREQUESTL_EXIT );

    }

void CMTPDataProvider::EnumerateObjectsL(TUint32 aStorageId)

    {

    OstTraceFunctionEntry0( CMTPDATAPROVIDER_ENUMERATEOBJECTSL_ENTRY );

    OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_ENUMERATEOBJECTSL, 

            "data provider %d ", iId);      

    iEnumerationState = ((iEnumerationState & ~EObjectsEnumerationState) | EObjectsEnumerating);

    TBool abnormaldown = EFalse;

    iSingletons.FrameworkConfig().GetValueL(CMTPFrameworkConfig::EAbnormalDown, abnormaldown);

    iImplementation->StartObjectEnumerationL(aStorageId, abnormaldown);

    OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_ENUMERATEOBJECTSL, 

            "data provider %d ", iId);    

    OstTraceFunctionExit0( CMTPDATAPROVIDER_ENUMERATEOBJECTSL_EXIT );

    }

void CMTPDataProvider::EnumerateStoragesL()

    {

    OstTraceFunctionEntry0( CMTPDATAPROVIDER_ENUMERATESTORAGESL_ENTRY );

    OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_ENUMERATESTORAGESL, 

            "data provider %d ", iId);    

    iEnumerationState = ((iEnumerationState & ~EStoragesEnumerationState) | EStoragesEnumerating);

    iImplementation->StartStorageEnumerationL();

    OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_ENUMERATESTORAGESL, 

            "data provider %d ", iId);         

    OstTraceFunctionExit0( CMTPDATAPROVIDER_ENUMERATESTORAGESL_EXIT );   

    }

/**

Provides the data provider's enumeration state.

@return The data provider's enumeration state.

*/

EXPORT_C TUint CMTPDataProvider::EnumerationState() const

	{

    return iEnumerationState;	

	}

/**

Provides the data provider's implementation UID

@return The data provider's implementation UID.

*/

EXPORT_C TUid CMTPDataProvider::ImplementationUid() const 

    {

    return iImplementationUid;

    }

/**

Provides the handle of the bound data provider plug-in.

@return The data provider plug-in.

*/

EXPORT_C CMTPDataProviderPlugin& CMTPDataProvider::Plugin() const

    {

    __ASSERT_DEBUG(iImplementation, User::Invariant());

    return *iImplementation;

    }

EXPORT_C TBool CMTPDataProvider::Supported(TMTPSupportCategory aCategory, TUint aCode) const

    {

    return iSupported[aCategory]->Supported(aCode);

    }

EXPORT_C const RArray<TUint>& CMTPDataProvider::SupportedCodes(TMTPSupportCategory aCategory) const

    {

    return iSupported[aCategory]->Codes();

    }

/**

Sets the 

*/    

void CMTPDataProvider::SetDataProviderId(TUint aId)

    {

    OstTraceFunctionEntry0( CMTPDATAPROVIDER_SETDATAPROVIDERID_ENTRY );

    OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_SETDATAPROVIDERID, 

            "data provider %d ", iId);      

    iId = aId;

    OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_SETDATAPROVIDERID, 

            "data provider %d ", iId);        

    OstTraceFunctionExit0( CMTPDATAPROVIDER_SETDATAPROVIDERID_EXIT );

    }

/**

Implements a linear order relation for @see CMTPDataProvider 

objects based on relative @see CMTPDataProvider::ImplementationUid.

@param aUid The implementation UID object to match.

@param aObject The object instance to match.

@return Zero, if the two objects are equal; A negative value, if the first 

object is less than the second, or; A positive value, if the first object is 

greater than the second.

*/     

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

    {

    return (aUid->iUid - aObject.ImplementationUid().iUid);

    }

/**

Implements a @see TLinearOrder for @see CMTPDataProvider objects based on 

relative @see CMTPDataProvider::ImplementationUid.

@param aL The first object instance.

@param aR The second object instance.

@return Zero, if the two objects are equal; A negative value, if the first 

object is less than the second, or; A positive value, if the first object is 

greater than the second.

*/   

TInt CMTPDataProvider::LinearOrderUid(const CMTPDataProvider& aL, const CMTPDataProvider& aR)

    {

    return (aL.iImplementationUid.iUid - aR.iImplementationUid.iUid);

    }

/**

Implements a @see TLinearOrder for @see CMTPDataProvider objects based on 

relative @see CMTPDataProvider::DataProviderId.

@param aDPId The Dataprovider ID to match.

@param aR The second object instance.

@return Zero, if the two objects are equal; A negative value, if the first 

object is less than the second, or; A positive value, if the first object is 

greater than the second.

*/   

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

    {

    return (*aDPId - aObject.DataProviderId());

    }

/**

Implements a @see TLinearOrder for @see CMTPDataProvider objects based on 

relative @see CMTPDataProvider::DataProviderId.

@param aL The first object instance.

@param aR The second object instance.

@return Zero, if the two objects are equal; A negative value, if the first 

object is less than the second, or; A positive value, if the first object is 

greater than the second.

*/   

TInt CMTPDataProvider::LinearOrderDPId(const CMTPDataProvider& aL, const CMTPDataProvider& aR)

    {

    return (aL.DataProviderId() - aR.DataProviderId());

    }

/**

Implements a @see TLinearOrder for @see CMTPDataProvider objects based on 

relative enumeration phase

@param aL The first object instance.

@param aR The second object instance.

@return Zero, if the two objects are equal; A negative value, if the first 

object is less than the second, or; A positive value, if the first object is 

greater than the second.

*/   

TInt CMTPDataProvider::LinearOrderEnumerationPhase(const CMTPDataProvider& aL, const CMTPDataProvider& aR)

    {    

    return (aL.DataProviderConfig().UintValue(MMTPDataProviderConfig::EEnumerationPhase)

    	      - aR.DataProviderConfig().UintValue(MMTPDataProviderConfig::EEnumerationPhase));

    }

TUint CMTPDataProvider::DataProviderId() const

    {

    return iId;

    }    

TMTPOperationalMode CMTPDataProvider::Mode() const

    {

    return (iSingletons.DpController().Mode());    

    }

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

    {

    OstTraceFunctionEntry0( CMTPDATAPROVIDER_RECEIVEDATAL_ENTRY );

    OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_RECEIVEDATAL, 

            "data provider %d ", iId);       

    __ASSERT_DEBUG(iImplementation, User::Invariant());

    __ASSERT_DEBUG(!IsActive(), User::Invariant());

    if (iProxy)

        {

        // Pass to proxy plugin for processing

        iProxy->ProxyReceiveDataL(aData, aRequest, aConnection, iStatus);

        SetActive();

        // Running under proxy mode so manually set the next transaction phase to be processed by the plugin

        iProxyTransactionPhase = EResponsePhase;

        }

    else

        {

        // Inform the connection that we wish to receive data from the connection

        CMTPConnection& connection(iSingletons.ConnectionMgr().ConnectionL(aConnection.ConnectionId()));

        connection.ReceiveDataL(aData, aRequest, iStatus);

        SetActive();

        // Async call so wait for object to be activated...

        }

    OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_RECEIVEDATAL, 

            "data provider %d ", iId);     

    OstTraceFunctionExit0( CMTPDATAPROVIDER_RECEIVEDATAL_EXIT );    

    }

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

    {

    OstTraceFunctionEntry0( CMTPDATAPROVIDER_SENDDATAL_ENTRY );

    OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_SENDDATAL, 

            "data provider %d ", iId);       

    __ASSERT_DEBUG(iImplementation, User::Invariant());

    __ASSERT_DEBUG(!IsActive(), User::Invariant());

    if (iProxy)

        {

        // Pass to proxy plugin for processing

        iProxy->ProxySendDataL(aData,aRequest, aConnection, iStatus);

        SetActive();

        // Running under proxy mode so manually set the next transaction phase to be processed by the plugin

        iProxyTransactionPhase = EResponsePhase;

        }

    else

        {

        // Pass request to connection...

        CMTPConnection& connection(iSingletons.ConnectionMgr().ConnectionL(aConnection.ConnectionId()));

        connection.SendDataL(aData, aRequest, iStatus);

        SetActive();

        // Async call so wait for object to be activated...

        }

    OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_SENDDATAL, 

            "data provider %d ", iId);       

    OstTraceFunctionExit0( CMTPDATAPROVIDER_SENDDATAL_EXIT );

    }

void CMTPDataProvider::SendEventL(const TMTPTypeEvent& aEvent, MMTPConnection& aConnection)

    {

    OstTraceFunctionEntry0( CMTPDATAPROVIDER_SENDEVENTL_TMTPTYPEVENT_MMTPCONNECTION_ENTRY );

    OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_SENDEVENTL_TMTPTYPEVENT_MMTPCONNECTION, 

            "data provider %d ", iId);       

    __ASSERT_DEBUG(iImplementation, User::Invariant());

    CMTPConnection& connection(iSingletons.ConnectionMgr().ConnectionL(aConnection.ConnectionId()));

    connection.SendEventL(aEvent);

    OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_SENDEVENTL_TMTPTYPEVENT_MMTPCONNECTION, 

            "data provider %d ", iId);     

    OstTraceFunctionExit0( CMTPDATAPROVIDER_SENDEVENTL_TMTPTYPEVENT_MMTPCONNECTION_EXIT );        

    }

void CMTPDataProvider::SendEventL(const TMTPTypeEvent& aEvent)

    {

    OstTraceFunctionEntry0( CMTPDATAPROVIDER_SENDEVENTL_TMTPTYPEVENT_ENTRY );

    OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_SENDEVENTL_TMTPTYPEVENT, 

            "data provider %d ", iId);         

    if (aEvent.Uint32(TMTPTypeEvent::EEventSessionID) != KMTPSessionAll)

        {

        OstTrace0( TRACE_ERROR, CMTPDATAPROVIDER_SENDEVENTL, "event session id not KMTPSessionALL!" );

        User::Leave(KErrArgument);            

        }

    TUint numConnections(iSingletons.ConnectionMgr().ConnectionCount());

    for (TUint i(0); (i < numConnections); i++)

        {

        iSingletons.ConnectionMgr()[i].SendEventL(aEvent);       

        }

    OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_SENDEVENTL_TMTPTYPEVENT, 

            "data provider %d ", iId);    

    OstTraceFunctionExit0( CMTPDATAPROVIDER_SENDEVENTL_TMTPTYPEVENT_EXIT );     

    }

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

    {

    OstTraceFunctionEntry0( CMTPDATAPROVIDER_SENDRESPONSEL_ENTRY );

    OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_SENDRESPONSEL, 

            "data provider %d ", iId);      

    __ASSERT_DEBUG(iImplementation, User::Invariant());

    __ASSERT_DEBUG(!IsActive(), User::Invariant());

    if (iProxy)

        {

        // Pass to proxy plugin for processing

        iProxy->ProxySendResponseL(aResponse, aRequest, aConnection, iStatus);

        SetActive();

        // Running under proxy mode so manually set the next transaction phase to be processed by the plugin

        iProxyTransactionPhase = ECompletingPhase;

        }

    else

        {

        CMTPConnection& connection(iSingletons.ConnectionMgr().ConnectionL(aConnection.ConnectionId()));

        connection.SendResponseL(aResponse, aRequest, iStatus);

        SetActive();

        }

    OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_SENDRESPONSEL, 

            "data provider %d ", iId);      

    OstTraceFunctionExit0( CMTPDATAPROVIDER_SENDRESPONSEL_EXIT );      

    }

void CMTPDataProvider::TransactionCompleteL(const TMTPTypeRequest& aRequest, MMTPConnection& aConnection)

    {

    OstTraceFunctionEntry0( CMTPDATAPROVIDER_TRANSACTIONCOMPLETEL_ENTRY );

    OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_TRANSACTIONCOMPLETEL, 

            "data provider %d ", iId);      

    __ASSERT_DEBUG(iImplementation, User::Invariant());

    if (iProxy)

        {

        // Pass to proxy plugin for processing

        iProxy->ProxyTransactionCompleteL(aRequest, aConnection);

        // Running under proxy mode so manually set the next transaction phase to be processed by the plugin

        iProxyTransactionPhase = ERequestPhase;

        }

    else

        {

        CMTPConnection& connection(iSingletons.ConnectionMgr().ConnectionL(aConnection.ConnectionId()));

        connection.TransactionCompleteL(aRequest);            

        }

    // Clear pointers

    iProxy = NULL;

    iCurrentRequest = NULL;

    iCurrentConnection = NULL;

    OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_TRANSACTIONCOMPLETEL, 

            "data provider %d ", iId);      

    OstTraceFunctionExit0( CMTPDATAPROVIDER_TRANSACTIONCOMPLETEL_EXIT );

    } 

void CMTPDataProvider::RouteRequestRegisterL(const TMTPTypeRequest& aRequest, MMTPConnection& aConnection)

    {

    OstTraceFunctionEntry0( CMTPDATAPROVIDER_ROUTEREQUESTREGISTERL_ENTRY );

    OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_ROUTEREQUESTREGISTERL, 

            "data provider %d ", iId);    

    iSingletons.Router().RouteRequestRegisterL(aRequest, aConnection, iId);

    OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_ROUTEREQUESTREGISTERL, 

            "data provider %d ", iId);       

    OstTraceFunctionExit0( CMTPDATAPROVIDER_ROUTEREQUESTREGISTERL_EXIT );     

    }

void CMTPDataProvider::RouteRequestUnregisterL(const TMTPTypeRequest& aRequest, MMTPConnection& aConnection)

    {

    OstTraceFunctionEntry0( CMTPDATAPROVIDER_ROUTEREQUESTUNREGISTERL_ENTRY );

    OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_ROUTEREQUESTUNREGISTERL, 

            "data provider %d ", iId);  

    iSingletons.Router().RouteRequestUnregisterL(aRequest, aConnection);

    OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_ROUTEREQUESTUNREGISTERL, 

            "data provider %d ", iId);      

    OstTraceFunctionExit0( CMTPDATAPROVIDER_ROUTEREQUESTUNREGISTERL_EXIT );    

    }

void CMTPDataProvider::ObjectEnumerationCompleteL(TUint32 aStorageId)

    {

    OstTraceFunctionEntry0( CMTPDATAPROVIDER_OBJECTENUMERATIONCOMPLETEL_ENTRY );

    OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_OBJECTENUMERATIONCOMPLETEL, 

            "data provider %d ", iId);      

    OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_OBJECTENUMERATIONCOMPLETEL, 

            "StorageId = 0x%08X ", aStorageId);      

    iEnumerationState = ((iEnumerationState & ~EObjectsEnumerationState) | EObjectsEnumerated);

    iSingletons.DpController().EnumerationStateChangedL(*this);

    OstTrace1(TRACE_NORMAL, DUP2_CMTPDATAPROVIDER_OBJECTENUMERATIONCOMPLETEL,