/*

* 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: GetPartialObject

*

*/

#include <mtp/cmtptypefile.h>

#include <mtp/mmtpdataproviderframework.h>

#include <mtp/cmtpobjectmetadata.h>

#include "cgetpartialobject.h"

#include "mmmtpdplogger.h"

#include "tmmmtpdppanic.h"

#include "ttypeflatbuf.h"

#include "mmmtpdpconfig.h"

/**

* Verification data for the GetPartialObject request

*/

const TMTPRequestElementInfo KMTPGetPartialObjectPolicy[] =

    {

        {TMTPTypeRequest::ERequestParameter1, EMTPElementTypeObjectHandle, EMTPElementAttrFile, 0, 0, 0}

    };

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

// CGetPartialObject::NewL

// Two-phase construction method

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

//

EXPORT_C MMmRequestProcessor* CGetPartialObject::NewL( MMTPDataProviderFramework& aFramework,

    MMTPConnection& aConnection,

    MMmMtpDpConfig& aDpConfig )

    {

    CGetPartialObject* self = new (ELeave) CGetPartialObject( aFramework, aConnection );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CGetPartialObject::~CGetPartialObject()

// Destructor

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

//

EXPORT_C CGetPartialObject::~CGetPartialObject()

    {

    delete iBuffer;

    delete iPartialData;

    delete iFileObject;

    }

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

// CGetPartialObject::CGetPartialObject

// Standard c++ constructor

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

//

EXPORT_C CGetPartialObject::CGetPartialObject( MMTPDataProviderFramework& aFramework,

    MMTPConnection& aConnection ) :

    CRequestProcessor( aFramework,

        aConnection,

        sizeof( KMTPGetPartialObjectPolicy ) / sizeof( TMTPRequestElementInfo ),

        KMTPGetPartialObjectPolicy ),

    iFramework ( aFramework ),

    iFs( iFramework.Fs() ),

    iBufferPtr8( NULL, 0 )

    {

    PRINT( _L( "Operation: GetPartialObject(0x101B)" ) );

    }

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

// CGetPartialObject::CheckRequestL

// Check the GetPartialObject reqeust

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

//

EXPORT_C TMTPResponseCode CGetPartialObject::CheckRequestL()

    {

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

    TMTPResponseCode result = CRequestProcessor::CheckRequestL();

    if( result == EMTPRespCodeOK && !VerifyParametersL() )

        {

        result = EMTPRespCodeInvalidParameter;

        }

    PRINT1( _L( "MM MTP <= CGetPartialObject::CheckRequestL result = ox%x" ), result );

    return result;

    }

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

// CGetPartialObject::VerifyParametersL

// Verify if the parameter of the request (i.e. offset) is good.

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

//

TBool CGetPartialObject::VerifyParametersL()

    {

    PRINT( _L( "MM MTP => CGetPartialObject::VerifyParametersL" ) );

    __ASSERT_DEBUG( iRequestChecker, Panic( EMmMTPDpRequestCheckNull ) );

    TBool result = EFalse;

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

    PRINT1( _L( "MM MTP <> CGetPartialObject::VerifyParametersL iObjectHandle = 0x%x" ), iObjectHandle );

    iOffset = Request().Uint32( TMTPTypeRequest::ERequestParameter2 );

    PRINT1( _L( "MM MTP <> CGetPartialObject::VerifyParametersL iOffset = %d" ), iOffset );

    TUint32 maxLength = Request().Uint32( TMTPTypeRequest::ERequestParameter3 );

    PRINT1( _L( "MM MTP <> CGetPartialObject::VerifyParametersL maxLength = %d" ), maxLength );

    //get object info, but do not have the ownship of the object

    CMTPObjectMetaData* objectInfo = iRequestChecker->GetObjectInfo( iObjectHandle );

    __ASSERT_DEBUG( objectInfo, Panic( EMmMTPDpObjectNull ) );

    const TDesC& suid( objectInfo->DesC( CMTPObjectMetaData::ESuid ) );

    PRINT1( _L( "MM MTP <> CGetPartialObject::VerifyParametersL suid = %S" ), &suid );

    if ( objectInfo->Uint( CMTPObjectMetaData::EDataProviderId )

        == iFramework.DataProviderId() )

        result = ETrue;

    TEntry fileEntry;

    User::LeaveIfError( iFs.Entry( suid, fileEntry ) );

    TInt64 fileSize = fileEntry.iSize;

    if( ( iOffset < fileEntry.iSize ) && result )

        {

        if ( maxLength == fileSize )

            {

            iCompleteFile = ETrue;

            }

        if( iOffset + maxLength > fileSize )

            {

            maxLength = fileSize - iOffset;

            }

        iPartialDataLength = maxLength;

        result = ETrue;

        }

    PRINT1( _L( "MM MTP <> CGetPartialObject::VerifyParametersL iPartialDataLength = %d" ), iPartialDataLength );

    PRINT1( _L( "MM MTP <= CGetPartialObject::VerifyParametersL result = %d" ), result );

    return result;

    }

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

// CGetPartialObject::ServiceL

// GetPartialObject request handler

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

//

EXPORT_C void CGetPartialObject::ServiceL()

    {

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

    // Get file information

    CMTPObjectMetaData* objectInfo = iRequestChecker->GetObjectInfo( iObjectHandle );

    __ASSERT_DEBUG( objectInfo, Panic( EMmMTPDpObjectNull ) );

    iFileSuid.SetLength( 0 );

    iFileSuid.Append( objectInfo->DesC( CMTPObjectMetaData::ESuid ) );

    if ( iCompleteFile )

        {

        // Pass the complete file back to the host

        delete iFileObject;

        iFileObject = NULL;

        iFileObject = CMTPTypeFile::NewL( iFramework.Fs(), iFileSuid, EFileRead );

        SendDataL( *iFileObject );

        }

    else

        {

        // Send partial file fragment back.

        BuildPartialDataL();

        delete iPartialData;

        iPartialData = NULL;

        iPartialData  = new (ELeave) TMTPTypeFlatBuf( iBufferPtr8 );

        SendDataL( *iPartialData );

        }

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

    }

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

// CGetPartialObject::DoHandleResponsePhaseL

// Signal to the initiator how much data has been sent

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

//

EXPORT_C TBool CGetPartialObject::DoHandleResponsePhaseL()

    {

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

    TUint32 dataLength = iPartialDataLength;

    PRINT1( _L( "MM MTP <> CGetPartialObject::DoHandleResponsePhaseL dataLength = %d" ), dataLength );

    SendResponseL( EMTPRespCodeOK, 1, &dataLength );

    PRINT( _L( "MM MTP <= CGetPartialObject::DoHandleResponsePhaseL" ) );

    return EFalse;

    }

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

// CGetPartialObject::ConstructL()

// Second-phase construction

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

//

void CGetPartialObject::ConstructL()

    {

    SetPSStatus();

    }

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

// CGetPartialObject::BuildPartialDataL()

// Populate the partial data object

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

//

void CGetPartialObject::BuildPartialDataL()

    {

    PRINT( _L( "MM MTP => CGetPartialObject::BuildPartialDataL" ) );

    __ASSERT_DEBUG( iRequestChecker, Panic( EMmMTPDpRequestCheckNull ) );

    if ( iBuffer )

        {

        delete iBuffer;

        iBuffer = NULL;

        }

    // We might fail if we have insufficient memory...

    iBuffer = HBufC8::NewL( iPartialDataLength );

    iBuffer->Des().Zero();

    iBufferPtr8.Set( iBuffer->Des() );

    RFile file;

    User::LeaveIfError( file.Open( iFs, iFileSuid, EFileRead ) );

    CleanupClosePushL( file ); // + file

    User::LeaveIfError( file.Read( iOffset, iBufferPtr8, iPartialDataLength ) );

    CleanupStack::PopAndDestroy( &file ); // - file

    PRINT( _L( "MM MTP <= CGetPartialObject::BuildPartialDataL" ) );

    }

// end of file