// 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/cmtpobjectmetadata.h>

#include <mtp/mtpprotocolconstants.h>

#include "cmtpconnection.h"

#include "cmtpdataprovider.h"

#include "cmtpdataprovidercontroller.h"

#include "cmtpframeworkconfig.h"

#include "cmtpobjectmgr.h"

#include "cmtpparserrouter.h"

#include "cmtpsession.h"

#include "cmtpstoragemgr.h"

#include "tmtptypeobjecthandle.h"

#include "cmtpservicemgr.h"

#include "mtpdebug.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmtpparserrouterTraces.h"

#endif

/**

Provides the byte size of the specified array.

*/

#define _ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))

/**

CMTPParserRouter panic codes.

*/

enum TMTPPanicReasons

    {

    EMTPPanicRoutingConflict = 0

    };

/**

Produces a "CMTPParserRouter" category panic.

@param aReason The panic code.

*/

LOCAL_C void Panic(TInt __DEBUG_ONLY(aReason))

    {

	__DEBUG_ONLY(_LIT(KMTPPanicCategory, "CMTPParserRouter"));

    __DEBUG_ONLY(User::Panic(KMTPPanicCategory, aReason));

    }

/**

Constructor.

*/

EXPORT_C CMTPParserRouter::TRoutingParameters::TRoutingParameters(const TMTPTypeRequest& aRequest, MMTPConnection& aConnection) :

    iConnection(aConnection),

    iRequest(aRequest),

    iParameters(iParameterData, ENumTypes)

    {

    Reset();

    }

/**

Copy constructor.

*/

CMTPParserRouter::TRoutingParameters::TRoutingParameters(const TRoutingParameters& aParams) :

    iConnection(aParams.iConnection),

    iRequest(aParams.iRequest),

    iParameters(iParameterData, ENumTypes)

    {

    iParameters.Copy(aParams.iParameters.Begin(), aParams.iParameters.Count());

    }

/**

Provides the handle of the MTP connection on associated with the operation.

@return The MTP connection handle.

*/    

EXPORT_C MMTPConnection& CMTPParserRouter::TRoutingParameters::Connection() const

    {

    return iConnection;

    }

/**

Provides the value of the specified parameter.

@param aId The parameter identifier.

@return The parameter value.

*/

EXPORT_C TUint CMTPParserRouter::TRoutingParameters::Param(CMTPParserRouter::TRoutingParameters::TParameterType aId) const

    {

    return iParameters[aId];

    }

/**

Resets all parameter values to zero.

*/

EXPORT_C void CMTPParserRouter::TRoutingParameters::Reset()

    {

    iParameters.Reset();

    }

/**

Provides the operation dataset associated with the operation.

@return The operation dataset.

*/

EXPORT_C const TMTPTypeRequest& CMTPParserRouter::TRoutingParameters::Request() const

    {

    return iRequest;

    }

/**

Sets the value of the specified parameter.

@param aId The parameter identifier.

@param aVal The new parameter value.

*/

EXPORT_C void CMTPParserRouter::TRoutingParameters::SetParam(CMTPParserRouter::TRoutingParameters::TParameterType aId, TUint aVal)

    {

    iParameters[aId] = aVal;

    }

/**

CMTPParserRouter factory method.

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

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

 */

CMTPParserRouter* CMTPParserRouter::NewL()

    {

    CMTPParserRouter* self = new (ELeave) CMTPParserRouter();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

/**

Destructor

*/

CMTPParserRouter::~CMTPParserRouter()

    {

    OstTraceFunctionEntry0( CMTPPARSERROUTER_CMTPPARSERROUTER_DES_ENTRY );

    iMaps.ResetAndDestroy();

    iSingletons.Close();

    OstTraceFunctionExit0( CMTPPARSERROUTER_CMTPPARSERROUTER_DES_EXIT );

    }

/**

Configures the parser/router. This processing primarily involves retrieving 

each data provider's set of supported category codes and using them to build

up the operation parameter lookup routing sub-type tables.

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

*/

EXPORT_C void CMTPParserRouter::ConfigureL()

    {

    OstTraceFunctionEntry0( CMTPPARSERROUTER_CONFIGUREL_ENTRY );

    const TUint KMapIds[] = 

        {

        ESubTypeDevicePropCode,

        ESubTypeObjectPropCode,

        ESubTypeOperationCode,

        ESubTypeStorageType,

        ESubTypeFormatCodeFormatSubcode,

        ESubTypeFormatCodeOperationCode,

        ESubTypeStorageTypeOperationCode,

        ESubTypeFormatCodeFormatSubcodeStorageType,

        ESubTypeServiceIDOperationCode

        };

    iMaps.ResetAndDestroy();

    for (TUint i(0); (i < _ARRAY_SIZE(KMapIds)); i++)

        {

        const TUint KSubType(KMapIds[i]);

        CMap* map(CMap::NewLC(KSubType));

        iMaps.AppendL(map);

        CleanupStack::Pop(map);

        RArray<TUint> p1Codes;

        RArray<TUint> p2Codes;

        RArray<TUint> p3Codes;

        CleanupClosePushL(p1Codes);

        CleanupClosePushL(p2Codes);

        CleanupClosePushL(p3Codes);

        GetMapParameterIdsL(KSubType, p1Codes, p2Codes, p3Codes);

        const TUint KParams(KSubType & ESubTypeParamsMask);

        switch (KParams)

            {

        case ESubTypeParams1:

            Configure1ParameterMapL(KSubType, p1Codes);

            break;

        case ESubTypeParams2:

            Configure2ParameterMapL(KSubType, p1Codes, p2Codes);

            break;

        case ESubTypeParams3:

            Configure3ParameterMapL(KSubType, p1Codes, p2Codes, p3Codes);

            break;

        default:

            __DEBUG_ONLY(User::Invariant());

            break;

            }

        CleanupStack::PopAndDestroy(&p3Codes);

        CleanupStack::PopAndDestroy(&p2Codes);

        CleanupStack::PopAndDestroy(&p1Codes);

        }

#ifdef OST_TRACE_COMPILER_IN_USE

    OSTMapsL();

#endif

    OstTraceFunctionExit0( CMTPPARSERROUTER_CONFIGUREL_EXIT );

    }

/**

Indicates if the specified MTP operation code is supported by any of the set 

of loaded data providers.

@param aOperation The MTP operation code.

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

*/    

EXPORT_C TBool CMTPParserRouter::OperationSupportedL(TUint16 aOperation) const

    {

    OstTraceFunctionEntry0( CMTPPARSERROUTER_OPERATIONSUPPORTEDL_ENTRY );

    RArray<TUint> from;

    RArray<TUint> to;

    CleanupClosePushL(from);

    CleanupClosePushL(to);

    from.AppendL(aOperation);

    iMaps[Index(ESubTypeOperationCode)]->GetToL(from, to);

    TBool ret(to.Count() > 0);

    CleanupStack::PopAndDestroy(&to);

    CleanupStack::PopAndDestroy(&from);

    OstTraceFunctionExit0( CMTPPARSERROUTER_OPERATIONSUPPORTEDL_EXIT );

    return (ret);

    }

/**

Parses the operation dataset supplied in the specified routing parameters 

object which encapsulates all information required to route the operation. 

The parsing process involves:

    1.  Extracting all relevant routing information from the received operation 

        dataset. Note that not all parameter data is extracted, only that which 

        is required to route the operation.

    2.  Coarse grain validating the parsed data. Specifically this involves 

        validating that any MTP StorageID or Object Handle parameter data refers 

        to valid entities that exist on the device.

    3.    Extracting additional meta-data related to specific data objects and/or 

        storages referred to in the operation dataset and which is required to 

        route the operation.

@param aParams The routing parameters object. On entry this contains the 

operation dataset to be parsed and the handle of the MTP connection on which it

was received. On exit this contains all information required to route the 

operation. 

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

*/

EXPORT_C void CMTPParserRouter::ParseOperationRequestL(TRoutingParameters& aParams) const

    {

    OstTraceFunctionEntry0( CMTPPARSERROUTER_PARSEOPERATIONREQUESTL_ENTRY );

    const TUint16 KOpCode(aParams.Request().Uint16(TMTPTypeRequest::ERequestOperationCode));

    OstTrace1(TRACE_NORMAL, CMTPPARSERROUTER_PARSEOPERATIONREQUESTL, "Operation Code = 0x%04X", KOpCode);

    switch (KOpCode)

        {

    case EMTPOpCodeGetStorageInfo:

        ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter1, TRoutingParameters::EParamStorageId, aParams);

        break;

    case EMTPOpCodeGetObjectInfo:

    case EMTPOpCodeGetObject:

    case EMTPOpCodeGetThumb:

    case EMTPOpCodeSetObjectProtection:

    case EMTPOpCodeMoveObject:

    case EMTPOpCodeCopyObject:        

    case EMTPOpCodeGetPartialObject:

    case EMTPOpCodeGetObjectReferences:

    case EMTPOpCodeSetObjectReferences:

    case EMTPOpCodeUpdateObjectPropList :

    case EMTPOpCodeDeleteObjectPropList :

        ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter1, TRoutingParameters::EParamObjectHandle, aParams);

        break; 

    case EMTPOpCodeGetObjectPropValue:

    case EMTPOpCodeSetObjectPropValue:

        ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter1, TRoutingParameters::EParamObjectHandle, aParams);

        ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter2, TRoutingParameters::EParamObjectPropCode, aParams);

        break; 

    case EMTPOpCodeDeleteObject:              

        ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter1, TRoutingParameters::EParamObjectHandle, aParams);

        ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter2, TRoutingParameters::EParamFormatCode, aParams); 

        break;

    case EMTPOpCodeSendObjectInfo:

        ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter1, TRoutingParameters::EParamStorageId, aParams);

        break;

    case EMTPOpCodeInitiateCapture: 

    case EMTPOpCodeInitiateOpenCapture:

        {   

        ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter1, TRoutingParameters::EParamStorageId, aParams);

        ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter2, TRoutingParameters::EParamFormatCode, aParams); 

        TUint format(aParams.Request().Uint32(TMTPTypeRequest::ERequestParameter2));

        if (format == KMTPNotSpecified32)

            {

            iSingletons.FrameworkConfig().GetValueL(MMTPFrameworkConfig::EDefaultObjectFormatCode, format);

            if (format == KMTPNotSpecified32)

                {

                format = EMTPFormatCodeUndefined;

                }

            aParams.SetParam(TRoutingParameters::EParamFormatCode, format);

            }

        }

        break; 

    case EMTPOpCodeSendObjectPropList:

        ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter1, TRoutingParameters::EParamStorageId, aParams);

        ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter3, TRoutingParameters::EParamFormatCode, aParams); 

        break;  

    case EMTPOpCodeGetDevicePropDesc:

    case EMTPOpCodeGetDevicePropValue:

    case EMTPOpCodeSetDevicePropValue:

    case EMTPOpCodeResetDevicePropValue:

        ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter1, TRoutingParameters::EParamDevicePropCode, aParams);

        break;

    case EMTPOpCodeGetObjectPropsSupported:

    case EMTPOpCodeGetInterdependentPropDesc:

    case EMTPOpCodeGetFormatCapabilities:

        ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter1, TRoutingParameters::EParamFormatCode, aParams); 

        break;

    case EMTPOpCodeGetObjectPropDesc:

        ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter1, TRoutingParameters::EParamObjectPropCode, aParams); 

        ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter2, TRoutingParameters::EParamFormatCode, aParams);

        break;

    case EMTPOpCodeGetObjectPropList:              

        ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter2, TRoutingParameters::EParamFormatCode, aParams);

        ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter1, TRoutingParameters::EParamObjectHandle, aParams);

        ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter3, TRoutingParameters::EParamObjectPropCode, aParams);

        break;

    case EMTPOpCodeGetServiceInfo :

    case EMTPOpCodeGetServiceCapabilities :

    case EMTPOpCodeGetServicePropDesc :

    case EMTPOpCodeGetServicePropList :

    case EMTPOpCodeSetServicePropList:

    case EMTPOpCodeDeleteServicePropList :

        {

        ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter1, TRoutingParameters::EParamServiceId, aParams);

        }

        break;

    case EMTPOpCodeGetDeviceInfo:

    case EMTPOpCodeOpenSession:

    case EMTPOpCodeCloseSession:

    case EMTPOpCodeGetStorageIDs:

    case EMTPOpCodeGetNumObjects:

    case EMTPOpCodeGetObjectHandles:

    case EMTPOpCodeSendObject:

    case EMTPOpCodeFormatStore:

    case EMTPOpCodeResetDevice:

    case EMTPOpCodeSelfTest:

    case EMTPOpCodePowerDown:

    case EMTPOpCodeSetObjectPropList:

    case EMTPOpCodeSkip:

    case EMTPOpCodeGetServiceIDs:

        default:

        break;

        }

    OstTraceFunctionExit0( CMTPPARSERROUTER_PARSEOPERATIONREQUESTL_EXIT );

    }

/**

Routes an MTP operation using the specified routing parameters. By default 

only operation parameter routing is performed.

@param aParams The routing parameters.

@param aTargets One exit, the set of data provider targets to which the 

operation should be dispatched.

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

*/

EXPORT_C void CMTPParserRouter::RouteOperationRequestL(const TRoutingParameters& aParams, RArray<TUint>& aTargets) const

    {

    OstTraceFunctionEntry0( CMTPPARSERROUTER_ROUTEOPERATIONREQUESTL_ENTRY );

    aTargets.Reset();

    // By default ETypeOperationParameter routing is always enabled.

    if (!(aParams.Param(TRoutingParameters::EFlagRoutingTypes) & ETypeOperationParameter))

        {

        const_cast<TRoutingParameters&>(aParams).SetParam(TRoutingParameters::EFlagRoutingTypes, ETypeOperationParameter);

        }

    // Get the routing and validation sub-types.

    RArray<TUint> routing;

    CleanupClosePushL(routing);

    RArray<TUint> validation;

    CleanupClosePushL(validation);

    RArray<TRoutingParameters> params;

    CleanupClosePushL(params);

    params.AppendL(TRoutingParameters(aParams));

    TRoutingParameters& param1(params[0]);

    GetRoutingSubTypesL(params, routing, validation);

    // Execute the routing sub-types.

    const TUint KCountParams(params.Count());

    for (TUint p(0); ((p < KCountParams) && (aTargets.Count() == 0)); p++)

        {

        const TRoutingParameters& KParam(params[p]);

        const TUint KCountRouting(routing.Count());

        for (TUint r(0); (r < KCountRouting); r++)

            {

            const TUint KRouting(routing[r]);

            if ((KRouting & ESubTypeParamsMask) == ESubTypeParams0)

                {

                RouteOperationRequest0ParametersL(KRouting, KParam, aTargets);

                }

            else

                {

                RouteOperationRequestNParametersL(KRouting, KParam, aTargets);

                }

            }

        }

    // Execute the validation sub-types.

    ValidateTargetsL(param1, validation, aTargets);

    const TUint KCountTargets(aTargets.Count());

    if ((KCountTargets == 0) && (param1.Param(TRoutingParameters::EFlagRoutingTypes) & ETypeFramework))

        {

        SelectTargetL(iSingletons.DpController().DeviceDpId(), aTargets);

        }

    else if (KCountTargets > 1)

        {

        if (param1.Param(TRoutingParameters::EFlagRoutingTypes) & ETypeFlagSingleTarget)

            {

            TUint target(KCountTargets);

            while (target-- > 1)

                {

                aTargets.Remove(target);

                }

            }

        else if (param1.Param(TRoutingParameters::EFlagRoutingTypes) & ETypeFramework)

            {

            aTargets.Reset();

            SelectTargetL(iSingletons.DpController().ProxyDpId(), aTargets);

            }

        }    

    CleanupStack::PopAndDestroy(&params);

    CleanupStack::PopAndDestroy(&validation);

    CleanupStack::PopAndDestroy(&routing);

    OstTraceFunctionExit0( CMTPPARSERROUTER_ROUTEOPERATIONREQUESTL_EXIT );

    }

/**

Indicates if a routing request with the specified MTP operation code is 

registered on the specified session.

@param aRequest The MTP operation requesty dataset specifying MTP operation 

code and session.

@param aConnection The handle of the MTP connection on which the operation

request is expected to be received.

@return ETrue if a routing request with the specified MTP operation code is 

registered on the session, otherwise EFalse.

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

*/

EXPORT_C TBool CMTPParserRouter::RouteRequestRegisteredL(const TMTPTypeRequest& aRequest, MMTPConnection& aConnection) const

    {

    OstTraceFunctionEntry0( CMTPPARSERROUTER_ROUTEREQUESTREGISTEREDL_ENTRY );

    TBool ret(EFalse);

    const TUint32 KSessionId(aRequest.Uint32(TMTPTypeRequest::ERequestSessionID));

    if ((KSessionId != KMTPSessionAll) && (aConnection.SessionWithMTPIdExists(KSessionId)))

        {

        CMTPSession& session(static_cast<CMTPSession&>(aConnection.SessionWithMTPIdL(KSessionId)));

        ret = session.RouteRequestRegistered(aRequest.Uint16(TMTPTypeRequest::ERequestOperationCode));

        }

    OstTraceFunctionExit0( CMTPPARSERROUTER_ROUTEREQUESTREGISTEREDL_EXIT );

    return ret;

    }

/**

Routes and dispatches the specified MTP event dataset. The only valid event 

that is accepted is CancelTransaction, all other event types are discarded. 

Events are routed to the same target to which the currently active operation 

was dispatched. If there is no active transaction in progress then the event 

will be discarded.

@param aEvent The MTP event dataset.

@param aConnection The MTP connection on which the event was received.

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

*/

void CMTPParserRouter::ProcessEventL(const TMTPTypeEvent& aEvent, CMTPConnection& aConnection) const

    {

    OstTraceFunctionEntry0( CMTPPARSERROUTER_PROCESSEVENTL_ENTRY );

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

        (aConnection.SessionWithMTPIdExists(aEvent.Uint32(TMTPTypeEvent::EEventSessionID))))

        {

        CMTPSession& session(static_cast<CMTPSession&>(aConnection.SessionWithMTPIdL(aEvent.Uint32(TMTPTypeEvent::EEventSessionID))));

        if (session.TransactionPhase() != EIdlePhase)

            {    

            iSingletons.DpController().DataProviderL(RoutingTargetL(session.ActiveRequestL(), aConnection)).ExecuteEventL(aEvent, aConnection);

            }

        }

    OstTraceFunctionExit0( CMTPPARSERROUTER_PROCESSEVENTL_EXIT );

    }

/**

Routes and dispatches the specified MTP operation (request) dataset.

@param aRequest The MTP operation (request) dataset.

@param aConnection The MTP connection on which the event was received.

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