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

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()

    {

    Cancel();

    iSupported.ResetAndDestroy();

    delete iImplementation;

    iSingletons.Close();

    // Only delete passed objects when fully constructed.

    if (iConstructed)

        {

        delete iConfig;

        }

	iTimer.Close();  

    }

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

    {   

    __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);

    }

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

    {

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

    iCurrentRequest = &aRequest;

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

    // Schedule data provider to process this request.  

    Schedule(); 

    }

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

    {

    iProxy = &aProxy;

    iCurrentRequest    = &aRequest;

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

    Schedule();

    }

void CMTPDataProvider::ExecutePendingRequestL()

    {

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

        {

        Schedule();

        }

    }

void CMTPDataProvider::EnumerateObjectsL(TUint32 aStorageId)

    {

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

    TBool abnormaldown = EFalse;

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

    iImplementation->StartObjectEnumerationL(aStorageId, abnormaldown);

    }

void CMTPDataProvider::EnumerateStoragesL()

    {

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

    iImplementation->StartStorageEnumerationL();

    }

/**

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)

    {

    iId = aId;

    }

/**

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)

    {

    __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...

        }

    }

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

    {

    __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...

        }

    }

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

    {

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

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

    connection.SendEventL(aEvent);

    }

void CMTPDataProvider::SendEventL(const TMTPTypeEvent& aEvent)

    {

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

        {

        User::Leave(KErrArgument);            

        }

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

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

        {

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

        }

    }

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

    {

    __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();

        }

    }

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

    {

    __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;

    } 

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

    {

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

    }

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

    {

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

    }

void CMTPDataProvider::ObjectEnumerationCompleteL(TUint32 aStorageId)

    {

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

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