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

//

/**

 @file

 @internalTechnology

*/

#include <f32file.h>

#include <bautils.h>

#include <e32const.h>

#include <mtp/mmtpdataproviderframework.h>

#include <mtp/cmtpobjectmetadata.h>

#include <mtp/cmtptypefile.h>

#include <mtp/cmtptypeobjectinfo.h>

#include <mtp/cmtptypeobjectproplist.h>

#include <mtp/cmtptypestring.h>

#include <mtp/mmtpobjectmgr.h>

#include <mtp/mmtpstoragemgr.h>

#include <mtp/mtpprotocolconstants.h>

#include <mtp/mmtpconnection.h>

#include <mtp/tmtptyperequest.h>

#include "mtpdebug.h"

#include "cmtpimagedpobjectpropertymgr.h"

#include "cmtpimagedpsendobjectinfo.h"

#include "mtpimagedppanic.h"

#include "mtpimagedpconst.h"

#include "cmtpimagedpthumbnailcreator.h"

#include "mtpimagedputilits.h"

#include "cmtpimagedp.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmtpimagedpsendobjectinfoTraces.h"

#endif

const TInt RollbackFuncCnt = 3;

const TMTPRequestElementInfo KMTPSendObjectPropListPolicy[] = 

    {

        {TMTPTypeRequest::ERequestParameter1, EMTPElementTypeStorageId, EMTPElementAttrWrite, 1, 0, 0}, 

        {TMTPTypeRequest::ERequestParameter2, EMTPElementTypeObjectHandle, EMTPElementAttrDir, 2, KMTPHandleAll, KMTPHandleNone}

    };

/**

Two-phase construction method

@param aFramework  The data provider framework

@param aConnection The connection from which the request comes

@return a pointer to the created request processor object

*/ 

MMTPRequestProcessor* CMTPImageDpSendObjectInfo::NewL(MMTPDataProviderFramework& aFramework, MMTPConnection& aConnection,CMTPImageDataProvider& aDataProvider)

    {

    CMTPImageDpSendObjectInfo* self = new (ELeave) CMTPImageDpSendObjectInfo(aFramework, aConnection,aDataProvider);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

/**

Destructor

*/    

CMTPImageDpSendObjectInfo::~CMTPImageDpSendObjectInfo()

    {

    OstTraceFunctionEntry0( CMTPIMAGEDPSENDOBJECTINFO_CMTPIMAGEDPSENDOBJECTINFO_DES_ENTRY );

    Rollback();

    iRollbackList.Close();

    delete iDateMod;

    delete iDateCreated;

    delete iFileReceived;

    delete iParentSuid;    

    delete iReceivedObject;

    delete iObjectInfo;

    delete iObjectPropList;

    OstTraceFunctionExit0( CMTPIMAGEDPSENDOBJECTINFO_CMTPIMAGEDPSENDOBJECTINFO_DES_EXIT );

    }

/**

Standard c++ constructor

@param aFramework    The data provider framework

@param aConnection    The connection from which the request comes

*/    

CMTPImageDpSendObjectInfo::CMTPImageDpSendObjectInfo(MMTPDataProviderFramework& aFramework, MMTPConnection& aConnection, CMTPImageDataProvider& aDataProvider) :

    CMTPRequestProcessor(aFramework, aConnection, 0, NULL),

    iDataProvider(aDataProvider),

    iHiddenStatus( EMTPVisible ),

    iObjectPropertyMgr(aDataProvider.PropertyMgr())

    {

    }

#define ADD_FSM_ENTRY(currentstate, event, nextstate, failedstate, action)   \

    iStateMachine[currentstate][event].iNextSuccessState = nextstate;        \

    iStateMachine[currentstate][event].iNextFailedState  = failedstate;      \

    iStateMachine[currentstate][event].iFsmAction        = action

/**

Second-phase construction

*/        

void CMTPImageDpSendObjectInfo::ConstructL()

    {

    OstTraceFunctionEntry0( CMTPIMAGEDPSENDOBJECTINFO_CONSTRUCTL_ENTRY );

    iRollbackList.ReserveL(RollbackFuncCnt);

    iExpectedSendObjectRequest.SetUint16(TMTPTypeRequest::ERequestOperationCode, EMTPOpCodeSendObject);

    iReceivedObject = CMTPObjectMetaData::NewL();

    iReceivedObject->SetUint(CMTPObjectMetaData::EDataProviderId, iFramework.DataProviderId());

    // build FSM matrix    

    // process sendobjectinfo/sendobjectproplist operation

    ADD_FSM_ENTRY(EStateIdle, EObjectInfoEvent,     EObjectInfoCheck, EStateIdle, FsmCheckObjectInfoParamsL);

    ADD_FSM_ENTRY(EStateIdle, EObjectPropListEvent, EObjectInfoCheck, EStateIdle, FsmCheckObjectPropListParamsL);

    ADD_FSM_ENTRY(EStateIdle, EObjectEvent,         EStateIdle,       EStateIdle, FsmCheckObjectParams);

    ADD_FSM_ENTRY(EObjectInfoCheck, EObjectInfoEvent,     EObjectInfoServ, EStateIdle, FsmServiceSendObjectInfoL);

    ADD_FSM_ENTRY(EObjectInfoCheck, EObjectPropListEvent, EObjectInfoServ, EStateIdle, FsmServiceSendObjectPropListL);

    ADD_FSM_ENTRY(EObjectInfoCheck, EObjectEvent,         EStateEnd,       EStateEnd,  NULL);

    ADD_FSM_ENTRY(EObjectInfoServ, EObjectInfoEvent,     EObjectInfoSucceed, EStateIdle, FsmDoHandleSendObjectInfoCompleteL);

    ADD_FSM_ENTRY(EObjectInfoServ, EObjectPropListEvent, EObjectInfoSucceed, EStateIdle, FsmDoHandleSendObjectPropListCompleteL);

    ADD_FSM_ENTRY(EObjectInfoServ, EObjectEvent,         EStateEnd,          EStateEnd,  NULL);

    // process sendobject operation

    ADD_FSM_ENTRY(EObjectInfoSucceed, EObjectInfoEvent,     EObjectInfoCheck, EStateIdle,          FsmCheckObjectInfoParamsL);

    ADD_FSM_ENTRY(EObjectInfoSucceed, EObjectPropListEvent, EObjectInfoCheck, EStateIdle,          FsmCheckObjectPropListParamsL);

    ADD_FSM_ENTRY(EObjectInfoSucceed, EObjectEvent,         EObjectCheck,     EObjectInfoSucceed,  FsmCheckObjectParams);

    ADD_FSM_ENTRY(EObjectCheck, EObjectInfoEvent,     EStateEnd,   EStateEnd,  NULL);

    ADD_FSM_ENTRY(EObjectCheck, EObjectPropListEvent, EStateEnd,   EStateEnd,  NULL);

    ADD_FSM_ENTRY(EObjectCheck, EObjectEvent,         EObjectServ, EObjectInfoSucceed, FsmServiceSendObjectL);

    ADD_FSM_ENTRY(EObjectServ, EObjectInfoEvent,     EStateEnd,   EStateEnd,  NULL);

    ADD_FSM_ENTRY(EObjectServ, EObjectPropListEvent, EStateEnd,   EStateEnd,  NULL);

    ADD_FSM_ENTRY(EObjectServ, EObjectEvent,         EStateIdle,  EObjectInfoSucceed, FsmDoHandleSendObjectCompleteL);

    OstTraceFunctionExit0( CMTPIMAGEDPSENDOBJECTINFO_CONSTRUCTL_EXIT );

    }

TBool CMTPImageDpSendObjectInfo::FsmCheckObjectInfoParamsL(CMTPImageDpSendObjectInfo* aObject, TAny *aPtr)

    {

    return aObject->CheckObjectInfoParamsL(aPtr);

    }

TBool CMTPImageDpSendObjectInfo::FsmCheckObjectPropListParamsL(CMTPImageDpSendObjectInfo* aObject, TAny *aPtr)

    {

    return aObject->CheckObjectPropListParamsL(aPtr);

    }

TBool CMTPImageDpSendObjectInfo::FsmCheckObjectParams(CMTPImageDpSendObjectInfo* aObject, TAny *aPtr)

    {

    return aObject->CheckObjectParams(aPtr);

    }

TBool CMTPImageDpSendObjectInfo::FsmServiceSendObjectInfoL(CMTPImageDpSendObjectInfo* aObject, TAny *aPtr)

    {

    return aObject->ServiceSendObjectInfoL(aPtr);

    }

TBool CMTPImageDpSendObjectInfo::FsmServiceSendObjectPropListL(CMTPImageDpSendObjectInfo* aObject, TAny *aPtr)

    {

    return aObject->ServiceSendObjectPropListL(aPtr);

    }

TBool CMTPImageDpSendObjectInfo::FsmServiceSendObjectL(CMTPImageDpSendObjectInfo* aObject, TAny *aPtr)

    {

    return aObject->ServiceSendObjectL(aPtr);

    }

TBool CMTPImageDpSendObjectInfo::FsmDoHandleSendObjectInfoCompleteL(CMTPImageDpSendObjectInfo* aObject, TAny *aPtr)

    {

    return aObject->DoHandleSendObjectInfoCompleteL(aPtr);

    }

TBool CMTPImageDpSendObjectInfo::FsmDoHandleSendObjectPropListCompleteL(CMTPImageDpSendObjectInfo* aObject, TAny *aPtr)

    {

    return aObject->DoHandleSendObjectPropListCompleteL(aPtr);

    }

TBool CMTPImageDpSendObjectInfo::FsmDoHandleSendObjectCompleteL(CMTPImageDpSendObjectInfo* aObject, TAny *aPtr)

    {

    return aObject->DoHandleSendObjectCompleteL(aPtr);

    }

/**

Verify the request

@return EMTPRespCodeOK if request is verified, otherwise one of the error response codes

*/    

TMTPResponseCode CMTPImageDpSendObjectInfo::CheckRequestL()

    {

    OstTraceFunctionEntry0( CMTPIMAGEDPSENDOBJECTINFO_CHECKREQUESTL_ENTRY );

    iOperationCode = Request().Uint16(TMTPTypeRequest::ERequestOperationCode);

    switch (iOperationCode)

        {      

    case EMTPOpCodeSendObjectInfo:

        iEvent = EObjectInfoEvent;

        iElementCount = sizeof(KMTPSendObjectPropListPolicy) / sizeof(TMTPRequestElementInfo); //for the checker

        iElements = KMTPSendObjectPropListPolicy;            

        break;

    case EMTPOpCodeSendObjectPropList:

        iEvent = EObjectPropListEvent;

        iElementCount = sizeof(KMTPSendObjectPropListPolicy) / sizeof(TMTPRequestElementInfo); //for the checker

        iElements = KMTPSendObjectPropListPolicy;

        break;

    case EMTPOpCodeSendObject:

    	  //In ParseRouter everytime SendObject gets resolved then will be removed from Registry

    	  //Right away therefore we need reRegister it here again in case possible cancelRequest

    	  //Against this SendObject being raised.

    	  iExpectedSendObjectRequest.SetUint32(TMTPTypeRequest::ERequestSessionID, iSessionId);

    	  iFramework.RouteRequestRegisterL(iExpectedSendObjectRequest, iConnection);

        iEvent = EObjectEvent;

        iElementCount = 0; //for the checker

        iElements = NULL;

        break;

    default:

        // Nothing to do

        break;

        }

    FsmAction pCheck = iStateMachine[iCurrentState][iEvent].iFsmAction;

    __ASSERT_ALWAYS((pCheck != NULL), Panic(EMTPImageDpNoMatchingProcessor));

    //coverity[var_deref_model]

    TMTPResponseCode result = CMTPRequestProcessor::CheckRequestL();

    if(EMTPRespCodeOK == result)

        {

        TBool ret = EFalse;

        TRAPD(err, ret = (*pCheck)(this, &result));

        if (ret)

            {

            iCurrentState = iStateMachine[iCurrentState][iEvent].iNextSuccessState;

            }

        else

            {

            iCurrentState = iStateMachine[iCurrentState][iEvent].iNextFailedState;

            }

        LEAVEIFERROR(err,

                OstTrace1( TRACE_ERROR, DUP1_CMTPIMAGEDPSENDOBJECTINFO_CHECKREQUESTL,

                        "the request check failed! error code %d", err ));

        }

    OstTrace1( TRACE_NORMAL, CMTPIMAGEDPSENDOBJECTINFO_CHECKREQUESTL, "Result: 0x%04x", result );

    OstTraceFunctionExit0( CMTPIMAGEDPSENDOBJECTINFO_CHECKREQUESTL_EXIT );

    return result;    

    }

TBool CMTPImageDpSendObjectInfo::HasDataphase() const

    {

    return ETrue;

    }

TBool CMTPImageDpSendObjectInfo::CheckObjectInfoParamsL(TAny *aPtr)

    {

    OstTraceFunctionEntry0( CMTPIMAGEDPSENDOBJECTINFO_CHECKOBJECTINFOPARAMSL_ENTRY );

    TMTPResponseCode* ret = static_cast<TMTPResponseCode*>(aPtr);

    *ret = EMTPRespCodeOK;

    const TUint32 storeId(Request().Uint32(TMTPTypeRequest::ERequestParameter1));

    const TUint32 parentHandle(Request().Uint32(TMTPTypeRequest::ERequestParameter2));

    // this checking is only valid when the second parameter is not a special value.

    if (parentHandle != KMTPHandleAll && parentHandle != KMTPHandleNone)

        {

        //does not take owernship

        CMTPObjectMetaData* parentObjInfo = CMTPObjectMetaData::NewLC();        

        if (iFramework.ObjectMgr().ObjectL(parentHandle, *parentObjInfo))

            {

            TUint32 storageId = parentObjInfo->Uint(CMTPObjectMetaData::EStorageId);   

            if (storeId != storageId)        

                {

                *ret = EMTPRespCodeInvalidObjectHandle;

                }

            }

        else

            {

            *ret = EMTPRespCodeInvalidObjectHandle;            

            }        

        CleanupStack::PopAndDestroy(parentObjInfo);

        }

    OstTraceFunctionExit0( CMTPIMAGEDPSENDOBJECTINFO_CHECKOBJECTINFOPARAMSL_EXIT );

    return (*ret == EMTPRespCodeOK) ? ETrue : EFalse;

    }

TBool CMTPImageDpSendObjectInfo::CheckObjectPropListParamsL(TAny *aPtr)

    {

    OstTraceFunctionEntry0( CMTPIMAGEDPSENDOBJECTINFO_CHECKOBJECTPROPLISTPARAMSL_ENTRY );

    TMTPResponseCode* ret = static_cast<TMTPResponseCode*>(aPtr);

    *ret = EMTPRespCodeOK;

    TMTPFormatCode formatCode = static_cast<TMTPFormatCode>(Request().Uint32(TMTPTypeRequest::ERequestParameter3));

    if (!IsFormatValid(formatCode))

        {

        *ret = EMTPRespCodeInvalidObjectFormatCode;

        }

    else

        {

        iStorageId = Request().Uint32(TMTPTypeRequest::ERequestParameter1);

        TUint32 objectSizeHigh = Request().Uint32(TMTPTypeRequest::ERequestParameter4);

        TUint32 objectSizeLow = Request().Uint32(TMTPTypeRequest::ERequestParameter5);

        iObjectSize = MAKE_TUINT64(objectSizeHigh, objectSizeLow);

        if (iStorageId == KMTPStorageDefault)

            {

            iStorageId = iFramework.StorageMgr().DefaultStorageId();

            }

        if(IsTooLarge(iObjectSize))

            {

            *ret = EMTPRespCodeObjectTooLarge;

            }

        }

    OstTraceFunctionExit0( CMTPIMAGEDPSENDOBJECTINFO_CHECKOBJECTPROPLISTPARAMSL_EXIT );

    return (*ret == EMTPRespCodeOK) ? ETrue : EFalse;

    }

TBool CMTPImageDpSendObjectInfo::CheckObjectParams(TAny *aPtr)

    {

    OstTraceFunctionEntry0( CMTPIMAGEDPSENDOBJECTINFO_CHECKOBJECTPARAMS_ENTRY );

    TMTPResponseCode* ret = static_cast<TMTPResponseCode*>(aPtr);

    *ret = EMTPRespCodeOK;

    /**

    * If the previous request is not the SendObjectInfo/SendObjectPropList/UpdateObjectPropList operation,

    * the SendObject operation should failed.

    */

    if ( (iPreviousTransactionID + 1) != Request().Uint32(TMTPTypeRequest::ERequestTransactionID))

        {

        *ret = EMTPRespCodeNoValidObjectInfo;

        }

    OstTraceFunctionExit0( CMTPIMAGEDPSENDOBJECTINFO_CHECKOBJECTPARAMS_EXIT );

    return (*ret == EMTPRespCodeOK) ? ETrue : EFalse;    

    }

/**

SendObjectInfo/SendObject request handler

NOTE: SendObjectInfo has to be comes before SendObject requests.  To maintain the state information

between the two requests, the two requests are combined together in one request processor.

*/    

void CMTPImageDpSendObjectInfo::ServiceL()

    {

    OstTraceFunctionEntry0( CMTPIMAGEDPSENDOBJECTINFO_SERVICEL_ENTRY );

    FsmAction pService = iStateMachine[iCurrentState][iEvent].iFsmAction;

    __ASSERT_DEBUG(pService, Panic(EMTPImageDpNoMatchingProcessor));

    TBool ret = EFalse;

    TRAPD(err, ret = (*pService)(this, NULL));

    if (ret)

        {

        iCurrentState = iStateMachine[iCurrentState][iEvent].iNextSuccessState;

        }

    else

        {

        iCurrentState = iStateMachine[iCurrentState][iEvent].iNextFailedState;

        }    

    if (err != KErrNone)

        {

        Rollback();

        }

    LEAVEIFERROR(err,

            OstTrace1( TRACE_ERROR, CMTPIMAGEDPSENDOBJECTINFO_SERVICEL, "Action failed! error code %d", err));

    OstTraceFunctionExit0( CMTPIMAGEDPSENDOBJECTINFO_SERVICEL_EXIT );

    }

/**

Override to match both the SendObjectInfo and SendObject requests

@param aRequest    The request to match

@param aConnection The connection from which the request comes

@return ETrue if the processor can handle the request, otherwise EFalse

*/        

TBool CMTPImageDpSendObjectInfo::Match(const TMTPTypeRequest& aRequest, MMTPConnection& aConnection) const

    {

    OstTraceFunctionEntry0( CMTPIMAGEDPSENDOBJECTINFO_MATCH_ENTRY );

    TBool result = EFalse;

    TUint16 operationCode = aRequest.Uint16(TMTPTypeRequest::ERequestOperationCode);

    if ((operationCode == EMTPOpCodeSendObjectInfo || 

        operationCode == EMTPOpCodeSendObject ||

        operationCode == EMTPOpCodeSendObjectPropList) &&

        &iConnection == &aConnection)

        {

        result = ETrue;

        }

    OstTraceFunctionExit0( CMTPIMAGEDPSENDOBJECTINFO_MATCH_EXIT );

    return result;    

    }

/**

Override to handle the response phase of SendObjectInfo and SendObject requests

@return EFalse

*/

TBool CMTPImageDpSendObjectInfo::DoHandleResponsePhaseL()

    {

    OstTraceFunctionEntry0( CMTPIMAGEDPSENDOBJECTINFO_DOHANDLERESPONSEPHASEL_ENTRY );

    //to check if the sending/receiving data is successful

    iSuccessful = !iCancelled;

    FsmAction pResponse = iStateMachine[iCurrentState][iEvent].iFsmAction;

    __ASSERT_DEBUG(pResponse, Panic(EMTPImageDpNoMatchingProcessor));

    TBool ret = EFalse;

    TRAPD(err, ret = (*pResponse)(this, &iSuccessful))

    if (ret)

        {

        iCurrentState = iStateMachine[iCurrentState][iEvent].iNextSuccessState;

        }

    else

        {

        iCurrentState = iStateMachine[iCurrentState][iEvent].iNextFailedState;

        }          

    if (err != KErrNone)

        {

        Rollback();

        }

    LEAVEIFERROR(err,

            OstTrace1( TRACE_ERROR, CMTPIMAGEDPSENDOBJECTINFO_DOHANDLERESPONSEPHASEL, "Response error! error code %d", err));

    OstTraceFunctionExit0( CMTPIMAGEDPSENDOBJECTINFO_DOHANDLERESPONSEPHASEL_EXIT );

    return EFalse;

    }

/**

Override to handle the completing phase of SendObjectInfo and SendObject requests

@return ETrue if succesfully received the file, otherwise EFalse

*/    

TBool CMTPImageDpSendObjectInfo::DoHandleCompletingPhaseL()

    {

    OstTraceFunctionEntry0( CMTPIMAGEDPSENDOBJECTINFO_DOHANDLECOMPLETINGPHASEL_ENTRY );

    TBool result = ETrue;

    CMTPRequestProcessor::DoHandleCompletingPhaseL();

    if (iSuccessful)

        {

        if (iOperationCode == EMTPOpCodeSendObjectInfo || iOperationCode == EMTPOpCodeSendObjectPropList)

            {

            iPreviousTransactionID = Request().Uint32(TMTPTypeRequest::ERequestTransactionID);

            result = EFalse;

            }

        }

    else

        {

        if (iOperationCode == EMTPOpCodeSendObject)

            {

            iPreviousTransactionID++;

            }

        result = EFalse;

        }

    OstTraceFunctionExit0( CMTPIMAGEDPSENDOBJECTINFO_DOHANDLECOMPLETINGPHASEL_EXIT );

    return result;    

    }

/**

SendObjectInfo request handler

*/

TBool CMTPImageDpSendObjectInfo::ServiceSendObjectInfoL(TAny* /*aPtr*/)

    {

    OstTraceFunctionEntry0( CMTPIMAGEDPSENDOBJECTINFO_SERVICESENDOBJECTINFOL_ENTRY );

    delete iObjectInfo;

    iObjectInfo = NULL;

    iObjectInfo = CMTPTypeObjectInfo::NewL();

    ReceiveDataL(*iObjectInfo);

    OstTraceFunctionExit0( CMTPIMAGEDPSENDOBJECTINFO_SERVICESENDOBJECTINFOL_EXIT );

    return ETrue;

    }

/**

SendObjectPropList request handler

*/

TBool CMTPImageDpSendObjectInfo::ServiceSendObjectPropListL(TAny* /*aPtr*/)

    {

    OstTraceFunctionEntry0( CMTPIMAGEDPSENDOBJECTINFO_SERVICESENDOBJECTPROPLISTL_ENTRY );

    delete iObjectPropList;

    iObjectPropList = NULL;

    iObjectPropList = CMTPTypeObjectPropList::NewL();

    iReceivedObject->SetUint(CMTPObjectMetaData::EFormatCode, iRequest->Uint32(TMTPTypeRequest::ERequestParameter3));

    ReceiveDataL(*iObjectPropList);

    OstTraceFunctionExit0( CMTPIMAGEDPSENDOBJECTINFO_SERVICESENDOBJECTPROPLISTL_EXIT );

    return ETrue;

    }

/**

SendObject request handler

*/    

TBool CMTPImageDpSendObjectInfo::ServiceSendObjectL(TAny* /*aPtr*/)

    {

    OstTraceFunctionEntry0( CMTPIMAGEDPSENDOBJECTINFO_SERVICESENDOBJECTL_ENTRY );

    iFramework.ObjectMgr().CommitReservedObjectHandleL(*iReceivedObject);

    //prepare for rollback