/*

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

*

*/

#include <mtp/mmtpdataproviderframework.h>

#include <mtp/cmtptypeobjectproplist.h>

#include <mtp/mmtpobjectmgr.h>

#include <mtp/cmtptypestring.h>

#include <mtp/cmtptypearray.h>

#include "csetobjectproplist.h"

#include "cmmmtpdpmetadataaccesswrapper.h"

#include "mmmtpdputility.h"

#include "mmmtpdplogger.h"

#include "mmmtpdpconfig.h"

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

// CSetObjectPropList::NewL

// Two-phase construction method

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

//

//EXPORT_C MMmRequestProcessor* CSetObjectPropList::NewL( MMTPDataProviderFramework& aFramework,

//    MMTPConnection& aConnection,

//    CMmMtpDpMetadataAccessWrapper& aWrapper )

//    {

//    CSetObjectPropList* self = new ( ELeave ) CSetObjectPropList( aFramework,

//        aConnection,

//        aWrapper );

//    CleanupStack::PushL( self );

//    self->ConstructL();

//    CleanupStack::Pop( self );

//    return self;

//    }

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

// CSetObjectPropList::CSetObjectPropList

// Standard c++ constructor

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

//

EXPORT_C CSetObjectPropList::CSetObjectPropList( MMTPDataProviderFramework& aFramework,

    MMTPConnection& aConnection,

    MMmMtpDpConfig& aDpConfig ) :

    CRequestProcessor( aFramework, aConnection, 0, NULL),

    iObjectMgr( aFramework.ObjectMgr() ),

    iFs( aFramework.Fs() ),

    iDpConfig( aDpConfig ),

    iUnprocessedIndex ( 0 )

    {

    PRINT( _L( "Operation: SetObjectPropList(0x9806)" ) );

    }

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

// CSetObjectPropList::ConstructL

// 2nd Phase Constructor

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

//

EXPORT_C void CSetObjectPropList::ConstructL()

    {

    CActiveScheduler::Add( this );

    iPropertyList = CMTPTypeObjectPropList::NewL();

    SetPSStatus();

    }

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

// CSetObjectPropList::~CSetObjectPropList

// Destructor

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

//

EXPORT_C CSetObjectPropList::~CSetObjectPropList()

    {

    Cancel();

    delete iPropertyList;

    }

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

// CSetObjectPropList::ServiceL

// SetObjectPropList request handler

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

//

EXPORT_C void CSetObjectPropList::ServiceL()

    {

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

    // Recieve the data from the property list

    ReceiveDataL( *iPropertyList );

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

    }

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

// CSetObjectPropList::DoHandleResponsePhaseL

// Completing phase for the request handler

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

//

EXPORT_C TBool CSetObjectPropList::DoHandleResponsePhaseL()

    {

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

    iElementCount = iPropertyList->NumberOfElements();

    iPropertyList->ResetCursor();

    if( iElementCount > 0 )

        {

        iUnprocessedIndex = 0;

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, iStatus.Int() );

        SetActive();

        }

    else

        {

        SendResponseL( EMTPRespCodeOK );

        }

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

    return EFalse;

    }

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

// CSetObjectPropList::SetObjectPropListL

// Set object proplist

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

//

TMTPResponseCode CSetObjectPropList::SetObjectPropListL(

        const CMTPTypeObjectPropListElement& aPropListElement )

    {

    PRINT( _L( "MM MTP => CSetObjectPropList::SetObjectPropListL" ) );

    TMTPTypeUint16 protectionStatus( EMTPProtectionNoProtection );

    TMTPResponseCode responseCode( EMTPRespCodeOK );

    TUint32 handle = aPropListElement.Uint32L( CMTPTypeObjectPropListElement::EObjectHandle );

    TUint16 propertyCode = aPropListElement.Uint16L( CMTPTypeObjectPropListElement::EPropertyCode );

    TUint16 dataType = aPropListElement.Uint16L( CMTPTypeObjectPropListElement::EDatatype );

    PRINT3( _L( "MM MTP <> handle = 0x%x, propertyCode = 0x%x, dataType = 0x%x" ),

        handle, propertyCode, dataType );

    responseCode = MmMtpDpUtility::CheckPropType( propertyCode, dataType );

    PRINT1( _L( "MM MTP <> CheckPropType response code is 0x%x" ), responseCode );

    if( responseCode != EMTPRespCodeOK )

        return responseCode;

    if ( iFramework.ObjectMgr().ObjectOwnerId( handle )

        == iFramework.DataProviderId() )

        {

        PRINT( _L( "MM MTP => CSetObjectPropList::SetObjectPropListL enter" ) );

        CMTPObjectMetaData* object = CMTPObjectMetaData::NewLC(); // + object

        iFramework.ObjectMgr().ObjectL( handle, *object );

        if ( protectionStatus.Value() != EMTPProtectionNoProtection )

            {

            //for some reason, P4S expects Access Denied response instead of write protected

            return EMTPRespCodeAccessDenied; // EMTPRespCodeObjectWriteProtected;

            }

        switch ( propertyCode )

            {

            case EMTPObjectPropCodeStorageID:

            case EMTPObjectPropCodeObjectFormat:

            case EMTPObjectPropCodeProtectionStatus:

            case EMTPObjectPropCodeObjectSize:

            case EMTPObjectPropCodeParentObject:

            case EMTPObjectPropCodePersistentUniqueObjectIdentifier:

            case EMTPObjectPropCodeNonConsumable:

            case EMTPObjectPropCodeDateAdded:

            case EMTPObjectPropCodeDateCreated:

            case EMTPObjectPropCodeDateModified:

                {

                responseCode = EMTPRespCodeAccessDenied;

                }

                break;

            case EMTPObjectPropCodeObjectFileName:

                {

                TPtrC suid( object->DesC( CMTPObjectMetaData::ESuid ) );

                TBuf<KMaxFileName> newSuid( aPropListElement.StringL(

                    CMTPTypeObjectPropListElement::EValue ) );

                TInt err = KErrNone;

                err = MmMtpDpUtility::UpdateObjectFileName( iFramework.Fs(), suid, newSuid );

                PRINT1( _L( "MM MTP <> Update object file name err = %d" ), err );

                if ( KErrOverflow == err ) // full path name is too long

                    {

                    responseCode = EMTPRespCodeInvalidDataset;

                    }

                else if ( ( KErrNone == err ) || ( KErrAlreadyExists == err ) )

                    {

                    TRAP( err, iDpConfig.GetWrapperL().RenameObjectL( suid, newSuid ) ); //Update MPX DB

                    PRINT1( _L( "MM MTP <> Rename Object err = %d" ), err );

                    // it is ok if file is not found in DB, following S60 solution

                    if ( KErrNotFound == err )

                        {

                        TRAP( err, iDpConfig.GetWrapperL().AddObjectL( newSuid ) );

                        PRINT1( _L( "MM MTP <> Add Object err = %d" ), err );

                        }

                    if ( KErrNone == err )

                        {

                        object->SetDesCL( CMTPObjectMetaData::ESuid, newSuid );

                        iFramework.ObjectMgr().ModifyObjectL( *object );

                        }

                    else

                        {

                        responseCode = EMTPRespCodeGeneralError;

                        }

                    }

                }

                break;

            case EMTPObjectPropCodeName:

                {

                CMTPTypeString* stringData = CMTPTypeString::NewLC(

                    aPropListElement.StringL(

                        CMTPTypeObjectPropListElement::EValue ) );// + stringData

                responseCode = ServiceMetaDataToWrapperL( propertyCode,

                    *stringData, *object );

                CleanupStack::PopAndDestroy( stringData );// - stringData

                }

                break;

            default:

                {

                /*// trap and handle with response code here, so correct fail index should report

                TRAPD( err, responseCode = ServiceSpecificObjectPropertyL( propertyCode, *object, aPropListElement ) );

                PRINT1( _L("MM MTP <> CSetObjectPropList::SetObjectPropListL, ServiceSpecificObjectPropertyL, err = %d"), err );

                if ( err == KErrNotSupported )

                    {

                    responseCode = EMTPRespCodeAccessDenied;

                    }*/

                responseCode = ServiceSpecificObjectPropertyL( propertyCode, *object,

                    aPropListElement );

                }

                break;

            }

        CleanupStack::PopAndDestroy( object ); // - object

        }

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

    return responseCode;

    }

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

// CSetObjectPropList::HasDataphase

// Decide if has data phase

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

//

EXPORT_C TBool CSetObjectPropList::HasDataphase() const

    {

    return ETrue;

    }

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

// CSetObjectPropList::ServiceMetaDataToWrapperL

//

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

//

EXPORT_C TMTPResponseCode CSetObjectPropList::ServiceMetaDataToWrapperL(

    const TUint16 aPropCode,

    MMTPType& aNewData,

    const CMTPObjectMetaData& aObjectMetaData )

    {

    TMTPResponseCode resCode = EMTPRespCodeOK;

    TRAPD( err, iDpConfig.GetWrapperL().SetObjectMetadataValueL( aPropCode,

        aNewData,

        aObjectMetaData ) );

    PRINT1( _L("MM MTP <> CSetObjectPropList::ServiceMetaDataToWrapperL err = %d"), err);

    if ( err == KErrNone )

        {

        resCode = EMTPRespCodeOK;

        }

    else if ( err == KErrTooBig )

        // according to the codes of S60

        {

        resCode = EMTPRespCodeInvalidDataset;

        }

    else if ( err == KErrPermissionDenied )

        {

        resCode = EMTPRespCodeAccessDenied;

        }

    else if ( err == KErrNotFound )

        {

        if( MmMtpDpUtility::HasMetadata( aObjectMetaData.Uint( CMTPObjectMetaData::EFormatCode ) ) )

            SendResponseL( EMTPRespCodeAccessDenied );

        }

    else

        {

        // add new virtual call to see if the above condition can be handle probably

        err = HandleSpecificWrapperError( err, aObjectMetaData );

        if ( err != KErrNone )

            resCode = EMTPRespCodeGeneralError;

        }

    PRINT1( _L( "MM MTP <= CSetObjectPropList::ServiceMetaDataToWrapperL resCode = 0x%x" ), resCode );

    return resCode;

    }

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

// CSetObjectPropList::RunL

//

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

//

EXPORT_C void CSetObjectPropList::RunL()

    {

    if ( iUnprocessedIndex <  iElementCount )

        {

        TMTPResponseCode responseCode = SetObjectPropListL( iPropertyList->GetNextElementL());

        if ( responseCode != EMTPRespCodeOK )

            {

            SendResponseL( responseCode, 1, &iUnprocessedIndex );

            }

        else

            {

            // Complete ourselves with current TRequestStatus

            // Increase index to process next handle on next round

            iUnprocessedIndex++;

            TRequestStatus* status = &iStatus;

            User::RequestComplete( status, iStatus.Int() );

            SetActive();

            }

        }

    else // all handles processed, can send data

        {

        SendResponseL( EMTPRespCodeOK );

        }

    }

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

// CSetObjectPropList::RunError

//

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

//

EXPORT_C TInt CSetObjectPropList::RunError( TInt aError )

    {

    PRINT1( _L( "MM MTP <> CSetObjectPropList::RunError with error %d" ), aError );

    // Reschedule ourselves

    // TODO: go to next index or increase?

    // iUnprocessedIndex++

//    TRequestStatus* status = &iStatus;

//    User::RequestComplete( status, aError );

//    SetActive();

    PRINT1( _L( "MM MTP <> CGetObjectPropList::RunError aError = %d" ), aError );

    TRAP_IGNORE( SendResponseL( EMTPRespCodeGeneralError ) );

    return KErrNone;

    }

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

// CSetObjectPropList::DoCancel()

// Cancel the process

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

//

EXPORT_C void CSetObjectPropList::DoCancel()

    {

    }

// end of file