/*

* 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:  Implement the operation: SendObjectInfo/SendObjectPropList/SendObject

*

*/

#include <mtp/mmtpdataproviderframework.h>

#include <mtp/mmtpobjectmgr.h>

#include <mtp/cmtptypestring.h>

#include <mtp/cmtptypeobjectinfo.h>

#include <mtp/cmtptypefile.h>

#include <mtp/mmtpstoragemgr.h>

#include <mtp/cmtpobjectmetadata.h>

#include <bautils.h>

#include <mtp/cmtptypeobjectproplist.h>

#include "csendobject.h"

#include "mmmtpdpconfig.h"

#include "mmmtpdputility.h"

#include "tmmmtpdppanic.h"

#include "mmmtpdplogger.h"

#include "cmmmtpdpmetadataaccesswrapper.h"

// Verification data for the SendObjectInfo request

const TMTPRequestElementInfo KMTPSendObjectInfoPolicy[] =

    {

        {

        TMTPTypeRequest::ERequestParameter1,

        EMTPElementTypeStorageId,

        EMTPElementAttrWrite,

        1,

        0,

        0

        },

        {

        TMTPTypeRequest::ERequestParameter2,

        EMTPElementTypeObjectHandle,

        EMTPElementAttrDir | EMTPElementAttrWrite,

        2,

        KMTPHandleAll,

        KMTPHandleNone

        }

    };

// -----------------------------------------------------------------------------

// CSendObject::~CSendObject

// Destructor

// -----------------------------------------------------------------------------

//

EXPORT_C CSendObject::~CSendObject()

    {

    if ( ( iProgress == EObjectInfoSucceed

            || iProgress == EObjectInfoFail

            || iProgress == EObjectInfoInProgress )

        && !iNoRollback )

        {

        // Not finished SendObjectInfo \ SendObject pair detected.

        Rollback();

        PRINT( _L( "MM MTP <> CSendObject::~CSendObject, Rollback" ) );

        }

    delete iFileReceived;

    delete iParentSuid;

    delete iObjectInfo;

    delete iObjectPropList;

    delete iDateMod;

    delete iReceivedObjectInfo;

    PRINT( _L( "MM MTP <= CSendObject::~CSendObject" ) );

    }

// -----------------------------------------------------------------------------

// CSendObject::CSendObject

// Standard C++ Constructor

// -----------------------------------------------------------------------------

//

    MMTPConnection& aConnection,

    MMmMtpDpConfig& aDpConfig ) :

        CRequestProcessor( aFramework, aConnection, 0, NULL),

        iFs( iFramework.Fs() ),

        iObjectMgr( iFramework.ObjectMgr() ),

        iDpConfig( aDpConfig )

    {

    PRINT( _L( "Operation: SendObjectInfo/SendObject/SendObjectPropList(0x100C/0x100D/0x9808)" ) );

    }

// -----------------------------------------------------------------------------

// CSendObject::ConstructL

// 2nd Phase Constructor

// -----------------------------------------------------------------------------

//

    {

    PRINT( _L( "MM MTP => CSendObject::ConstructL" ) );

    iExpectedSendObjectRequest.SetUint16( TMTPTypeRequest::ERequestOperationCode,

        EMTPOpCodeSendObject );

    iReceivedObjectInfo = CMTPObjectMetaData::NewL();

    iReceivedObjectInfo->SetUint( CMTPObjectMetaData::EDataProviderId,

        iFramework.DataProviderId() );

    PRINT1( _L( "MM MTP <> CSendObject::ConstructL DataProviderId = 0x%x" ), iFramework.DataProviderId());

    iNoRollback = EFalse;

    SetPSStatus();

    PRINT( _L( "MM MTP <= CSendObject::ConstructL" ) );

    }

// -----------------------------------------------------------------------------

// CSendObject::Match

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

// -----------------------------------------------------------------------------

//

EXPORT_C TBool CSendObject::Match( const TMTPTypeRequest& aRequest,

    MMTPConnection& aConnection ) const

    {

    TBool result = EFalse;

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

    if ( ( operationCode == EMTPOpCodeSendObjectInfo

            || operationCode == EMTPOpCodeSendObject

            || operationCode == EMTPOpCodeSendObjectPropList )

            && ( &iConnection == &aConnection ) )

        {

        result = ETrue;

        }

    return result;

    }

// -----------------------------------------------------------------------------

// CSendObject::CheckSendingState

// Helper Functions

// Verify if the SendObject request comes after SendObjectInfo request

// @return EMTPRespCodeOK if SendObject request comes after a valid SendObjectInfo request, otherwise

// EMTPRespCodeNoValidObjectInfo

// -----------------------------------------------------------------------------

//

TMTPResponseCode CSendObject::CheckSendingStateL()

    {

    PRINT( _L( "MM MTP => CSendObject::CheckSendingState" ) );

    TMTPResponseCode result = EMTPRespCodeOK;

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

    PRINT1( _L( "MM MTP <> CSendObject iOperationCode = 0x%x" ), iOperationCode );

    if ( iOperationCode == 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 );

        }

    if ( iProgress == EObjectNone )

        {

        if ( iOperationCode == EMTPOpCodeSendObject )

            {

            PRINT( _L( "MM MTP <> CSendObject::CheckSendingState  EMTPRespCodeNoValidObjectInfo" ) );

            result = EMTPRespCodeNoValidObjectInfo;

            }

        }

    else if ( iProgress == EObjectInfoSucceed )

        {

        if ( iOperationCode == EMTPOpCodeSendObjectInfo )

            {

            delete iObjectInfo;

            iObjectInfo = NULL;

            iProgress = EObjectNone;

            }

        else if ( iOperationCode == EMTPOpCodeSendObjectPropList )

            {

            delete iObjectPropList;

            iObjectPropList = NULL;

            iProgress = EObjectNone;

            }

        }

    else

        {

        Panic( EMmMTPDpSendObjectStateInvalid );

        }

    PRINT1( _L( "MM MTP <= CSendObject::CheckSendingState result = 0x%x" ), result );

    return result;

    }

// -----------------------------------------------------------------------------

// CSendObject::CheckRequestL

// Verify the reqeust

// -----------------------------------------------------------------------------

//

EXPORT_C TMTPResponseCode CSendObject::CheckRequestL()

    {

    PRINT( _L( "MM MTP => CSendObject::CheckRequestL" ) );

    TMTPResponseCode responseCode = CheckSendingStateL();

    if ( responseCode != EMTPRespCodeOK )

        {

        return responseCode;

        }

    if ( iProgress == EObjectNone )

    // Only SendObjectInfo/SendObjectPropList's request phase will enter into this function,

    // otherwise, state machine of fw should be wrong.

        {

        iElementCount = sizeof( KMTPSendObjectInfoPolicy ) / sizeof( TMTPRequestElementInfo );

        iElements = KMTPSendObjectInfoPolicy;

        }

    else if ( iProgress == EObjectInfoSucceed )

        {

        iElementCount = 0;

        iElements = NULL;

        }

    if ( iElements != NULL )

        {

        responseCode = CRequestProcessor::CheckRequestL();

        if ( responseCode != EMTPRespCodeOK )

            {

            return responseCode;

            }

        // Reserve storageId and parent into member data variables if they are matched.

        responseCode = MatchStoreAndParentL();

        if ( responseCode != EMTPRespCodeOK )

            {

            return responseCode;

            }

        if ( iOperationCode == EMTPOpCodeSendObjectPropList )

            {

            // check if it is what dp supported

            iObjectFormat = Request().Uint32( TMTPTypeRequest::ERequestParameter3 );

            if ( iObjectFormat != KMTPFormatsAll )

                {

                responseCode = EMTPRespCodeInvalidObjectFormatCode;

                const RArray<TUint>* format = iDpConfig.GetSupportedFormat();

                TInt count = format->Count();

                for ( TInt i = 0; i < count; i++ )

                    {

                    if ( iObjectFormat == ( *format )[i] )

                        {

                        responseCode = EMTPRespCodeOK;

                        break;

                        }

                    }

                if ( responseCode != EMTPRespCodeOK )

                    {

                    return responseCode;

                    }

                } // end of if ( iObjectFormat != KMTPFormatsAll )

            // check object size

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

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

            iObjectSize = MAKE_TUINT64( objectSizeHigh, objectSizeLow );

            PRINT1( _L( "MM MTP <> CSendObject::CheckRequestL iObjectSize = %Lu" ), iObjectSize );

            if ( IsTooLarge( iObjectSize ) )

                {

                responseCode = EMTPRespCodeObjectTooLarge;

                }

            if ( ( responseCode != EMTPRespCodeOK ) && !CanStoreFileL( iStorageId, iObjectSize ) )

                {

                responseCode = EMTPRespCodeStoreFull;

                }

            }

        }

    PRINT1( _L( "MM MTP <= CSendObject::CheckRequestL, responseCode = 0x%x" ), responseCode );

    return responseCode;

    }

// -----------------------------------------------------------------------------

// CSendObject::HasDataphase

// Exception handling. CRequestProcessor will receive data if this operation

// won't by return ETrue.

// @return ETrue if there is data need to be received from initiator

// -----------------------------------------------------------------------------

//

EXPORT_C TBool CSendObject::HasDataphase() const

    {

    return ETrue;

    }

// -----------------------------------------------------------------------------

// CSendObject::ServiceL

// ServiceL request handler

// -----------------------------------------------------------------------------

//

EXPORT_C void CSendObject::ServiceL()

    {

    PRINT( _L( "MM MTP => CSendObject::ServiceL" ) );

    if ( iProgress == EObjectNone )

        {

        if ( iOperationCode == EMTPOpCodeSendObjectInfo )

            {

            ServiceInfoL();

            }

        else

            {

            ServicePropListL();

            }

        }

    else

        {

        PRINT1( _L( "MM MTP <> CSendObject::ServiceL, iProgress = %d" ), iProgress );

        ServiceObjectL();

        }

    PRINT( _L( "MM MTP <= CSendObject::ServiceL" ) );

    }

// -----------------------------------------------------------------------------

// CSendObject::ServiceInfoL

// ServiceL - Recieves the objectinfo data

// -----------------------------------------------------------------------------

//

void CSendObject::ServiceInfoL()

    {

    PRINT( _L( "MM MTP => CSendObject::ServiceInfoL" ) );

    iObjectInfo = CMTPTypeObjectInfo::NewL();

    ReceiveDataL( *iObjectInfo );

    iProgress = EObjectInfoInProgress;

    PRINT( _L( "MM MTP <= CSendObject::ServiceInfoL" ) );

    }

// -----------------------------------------------------------------------------

// CSendObject::ServicePropListL

// SendObjectPropList

// -----------------------------------------------------------------------------

//

void CSendObject::ServicePropListL()

    {

    PRINT( _L( "MM MTP => CSendObject::ServicePropListL" ) );

    iObjectPropList = CMTPTypeObjectPropList::NewL();

    ReceiveDataL( *iObjectPropList );

    iProgress = EObjectInfoInProgress;

    PRINT( _L( "MM MTP <= CSendObject::ServicePropListL" ) );

    }

// -----------------------------------------------------------------------------

// CSendObject::ServiceObjectL

// SendObject

// -----------------------------------------------------------------------------

//

void CSendObject::ServiceObjectL()

    {

    PRINT( _L( "MM MTP => CSendObject::ServiceObjectL" ) );

    delete iFileReceived;

    iFileReceived = NULL;

    PRINT2( _L( "MM MTP <> CSendObject::ServiceObjectL, iFullPath is %S, iObjectSize: %Lu" ), &iFullPath, iObjectSize );

    TRAPD( err, iFileReceived = CMTPTypeFile::NewL( iFs,

        iFullPath,

        EFileWrite ) );

    PRINT1( _L("MM MTP <> CSendObject::ServiceObjectL, Leave Code is: %d"), err );

    User::LeaveIfError( err );

    iFileReceived->SetSizeL( iObjectSize );

    ReceiveDataL( *iFileReceived );

    iProgress = ESendObjectInProgress;

    PRINT( _L( "MM MTP <= CSendObject::ServiceObjectL" ) );

    }

// -----------------------------------------------------------------------------

// CSendObject::DoHandleResponsePhaseL

// Response Phase Handler

// -----------------------------------------------------------------------------

//

EXPORT_C TBool CSendObject::DoHandleResponsePhaseL()

    {

    PRINT( _L( "MM MTP => CSendObject::DoHandleResponsePhaseL" ) );

    // check if the sending/receiving data is successful

    TBool successful = !iCancelled;

    if ( iProgress == EObjectInfoInProgress )

        {

        if ( iOperationCode == EMTPOpCodeSendObjectInfo )

            {

            successful = DoHandleResponsePhaseInfoL();

            }

        else if ( iOperationCode == EMTPOpCodeSendObjectPropList )

            {

            successful = DoHandleResponsePhasePropListL();

            }

        iProgress = ( successful ? EObjectInfoSucceed : EObjectInfoFail );

        iPreviousOperation = iOperationCode;

        }

    else if ( iProgress == ESendObjectInProgress )

        {

        successful = DoHandleResponsePhaseObjectL();

        iProgress = ( successful ? ESendObjectSucceed : ESendObjectFail );

        }

    PRINT1( _L( "MM MTP <= CSendObject::DoHandleResponsePhaseL iProgress = %d" ), iProgress );

    return EFalse;

    }

// -----------------------------------------------------------------------------

// CSendObject::DoHandleResponsePhaseInfoL

// Handle Response - Checks whether the request was successful

// -----------------------------------------------------------------------------

//

TBool CSendObject::DoHandleResponsePhaseInfoL()

    {

    PRINT( _L( "MM MTP => CSendObject::DoHandleResponsePhaseInfoL" ) );

    TBool result = ETrue;

    // cache the width and height of video file

    iObjectFormat = iObjectInfo->Uint16L( CMTPTypeObjectInfo::EObjectFormat );

    iWidth = iObjectInfo->Uint32L( CMTPTypeObjectInfo::EImagePixWidth );

    iHeight = iObjectInfo->Uint32L( CMTPTypeObjectInfo::EImagePixWidth );

    PRINT3( _L("MM MTP <> CSendObject::DoHandleResponsePhaseInfoL iObjectFormat = 0x%x, iWidth = %d, iHeight = %d"),

        iObjectFormat,

        iWidth,

        iHeight );

    // TODO: dateModified is reserved for extention usage.

    delete iDateMod;

    iDateMod = NULL;

    iDateMod = iObjectInfo->StringCharsL( CMTPTypeObjectInfo::EDateModified ).AllocL();

    // check if storage is full

    iObjectSize = iObjectInfo->Uint32L( CMTPTypeObjectInfo::EObjectCompressedSize );

    PRINT1( _L("MM MTP <> CSendObject::DoHandleResponsePhaseInfoL, iObjectSize = %Lu"), iObjectSize );

    if ( IsTooLarge( iObjectSize ) )

        {

        SendResponseL( EMTPRespCodeObjectTooLarge );

        result = EFalse;

        }

    if ( result && !CanStoreFileL( iStorageId, iObjectSize ) )

        {

        SendResponseL( EMTPRespCodeStoreFull );

        result = EFalse;

        }

    if ( result )

        {

        iProtectionStatus = iObjectInfo->Uint16L( CMTPTypeObjectInfo::EProtectionStatus );

        PRINT1( _L( "MM MTP <> CSendObject::DoHandleResponsePhaseInfoL iProtectionStatus = %d" ), iProtectionStatus );

        if ( iProtectionStatus != EMTPProtectionNoProtection

            && iProtectionStatus != EMTPProtectionReadOnly )

            {

            SendResponseL( EMTPRespCodeParameterNotSupported );

            result = EFalse;

            }

        }

    if ( result )

        {

        result = GetFullPathNameL( iObjectInfo->StringCharsL( CMTPTypeObjectInfo::EFilename ) );

        if ( !result )

            {

            // File and/or parent pathname invalid.

            SendResponseL( EMTPRespCodeInvalidDataset );

            }

        }

    if ( result )

        {

        if ( ExistsL( iFullPath ) )

            {

            // Object with the same name already exists.

            iNoRollback = ETrue;

            SendResponseL( EMTPRespCodeAccessDenied );

            result = EFalse;

            }