/*

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

*

*/

#include <bautils.h>

#include <mtp/mmtpdataproviderframework.h>

#include <mtp/mmtpobjectmgr.h>

#include <mtp/mmtpstoragemgr.h>

#include <mtp/cmtpobjectmetadata.h>

#include <mtp/cmtptypearray.h>

#include <mtp/cmtptypestring.h>

#include <mtp/cmtptypeobjectproplist.h>

#include "cmoveobject.h"

#include "mmmtpdplogger.h"

#include "tmmmtpdppanic.h"

#include "mmmtpdputility.h"

#include "cmmmtpdpmetadataaccesswrapper.h"

#include "mmmtpdpconfig.h"

/**

* Verification data for the MoveObject request

*/

const TMTPRequestElementInfo KMTPMoveObjectPolicy[] =

    {

        {

        },

        {

        },

        {

        }

    };

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

// CMoveObject::~CMoveObject

// Destructor

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

//

EXPORT_C CMoveObject::~CMoveObject()

    {

    Cancel();

    delete iDest;

    if ( iPropertyElement )

        delete iPropertyElement;

    delete iPropertyList;

    }

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

// CMoveObject::CMoveObject

// Standard c++ constructor

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

//

EXPORT_C CMoveObject::CMoveObject( MMTPDataProviderFramework& aFramework,

    {

    PRINT( _L( "Operation: MoveObject(0x1019)" ) );

    }

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

// CMoveObject::ServiceL

// MoveObject request handler

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

//

EXPORT_C void CMoveObject::ServiceL()

    {

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

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

    }

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

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

//

    {

    PRINT( _L( "MM MTP => CMoveObject::MoveObjectL" ) );

    TMTPResponseCode responseCode = EMTPRespCodeOK;

    GetParametersL();

    RBuf newObjectName;

    newObjectName.CreateL( KMaxFileName );

    newObjectName.CleanupClosePushL(); // + newObjectName

    newObjectName = *iDest;

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

    TParsePtrC fileNameParser( suid );

        {

        }

    if ( responseCode == EMTPRespCodeOK )

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

    }

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

// CMoveObject::GetParametersL

// Retrieve the parameters of the request

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

//

void CMoveObject::GetParametersL()

    {

    PRINT( _L( "MM MTP => CMoveObject::GetParametersL" ) );

    __ASSERT_DEBUG( iRequestChecker, Panic( EMmMTPDpRequestCheckNull ) );

    TUint32 objectHandle = Request().Uint32( TMTPTypeRequest::ERequestParameter1 );

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

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

    // not taking owernship

    iObjectInfo = iRequestChecker->GetObjectInfo( objectHandle );

    __ASSERT_DEBUG( iObjectInfo, Panic( EMmMTPDpObjectNull ) );

        {

        SetDefaultParentObjectL();

        }

    else

        {

        delete iDest;

        iDest = NULL;

        PRINT1( _L( "MM MTP <> CMoveObject::GetParametersL iDest = %S" ), iDest );

        }

    PRINT( _L( "MM MTP <= CMoveObject::GetParametersL" ) );

    }

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

// CMoveObject::SetDefaultParentObjectL

// Get a default parent object, ff the request does not specify a parent object,

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

//

void CMoveObject::SetDefaultParentObjectL()

    {

    PRINT( _L( "MM MTP => CMoveObject::SetDefaultParentObjectL" ) );

    delete iDest;

    iDest = NULL;

    iNewParentHandle = KMTPHandleNoParent;

    }

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

// CMoveObject::CanMoveObjectL

// Check if we can move the file to the new location

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

//

TMTPResponseCode CMoveObject::CanMoveObjectL( const TDesC& aOldName,

    {

    TMTPResponseCode result = EMTPRespCodeOK;

    TEntry fileEntry;

    User::LeaveIfError( iFramework.Fs().Entry( aOldName, fileEntry ) );

    User::LeaveIfError( drive );

    TVolumeInfo volumeInfo;

    User::LeaveIfError( iFramework.Fs().Volume( volumeInfo, drive ) );

        {

        result = EMTPRespCodeStoreFull;

        }

    else if ( BaflUtils::FileExists( iFramework.Fs(), aNewName ) )

        {

#ifdef MMMTPDP_REPLACE_EXIST_FILE

        // delete the old one and replace

        TInt delErr = iFramework.Fs().Delete( aNewName );

        PRINT1( _L( "MM MTP <> CMoveObject::CanMoveObjectL delErr = %d" ), delErr );

        // delete from the metadata DB

        TRAPD( err, iFramework.ObjectMgr().RemoveObjectL( aNewName ) );

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

        // delete from video/mpx DB

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

        if ( iFramework.ObjectMgr().ObjectL( aNewName, *objectInfo ) )

            {

            TRAP( err, iDpConfig.GetWrapperL().DeleteObjectL( aNewName,

                objectInfo->Uint( CMTPObjectMetaData::EFormatCode ) ) );

            }

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

        if ( err )

            {

            // do nothing

            }

#else

        result = EMTPRespCodeInvalidParentObject;

#endif

        }

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

    return result;

    }

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

// CMoveObject::GetPreviousPropertiesL

// Save the object properties before doing the move

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

//

void CMoveObject::GetPreviousPropertiesL( const CMTPObjectMetaData& aObject )

    {

    PRINT( _L( "MM MTP => CMoveObject::GetPreviousPropertiesL" ) );

    const TDesC& suid( aObject.DesC( CMTPObjectMetaData::ESuid ) );

    User::LeaveIfError( iFramework.Fs().Modified( suid, iPreviousModifiedTime ) );

    // same storage, not necessary to get the properties

    if ( iSameStorage )

        return;

    TUint formatCode = aObject.Uint( CMTPObjectMetaData::EFormatCode );

    const RArray<TUint>* properties = iDpConfig.GetSupportedPropertiesL( formatCode );

    TInt count = properties->Count();

    TInt err = KErrNone;

    TUint16 propCode;

        {

        delete iPropertyElement;

        iPropertyElement = NULL;

        }

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

        {

            {

            case EMTPObjectPropCodeStorageID:

            case EMTPObjectPropCodeObjectFormat:

            case EMTPObjectPropCodeProtectionStatus:

            case EMTPObjectPropCodeObjectSize:

            case EMTPObjectPropCodeObjectFileName:

            case EMTPObjectPropCodeParentObject:

            case EMTPObjectPropCodePersistentUniqueObjectIdentifier:

            case EMTPObjectPropCodeDateCreated:

            case EMTPObjectPropCodeDateModified:

                break;

            case EMTPObjectPropCodeName:

            case EMTPObjectPropCodeDateAdded:

                if ( ( propCode == EMTPObjectPropCodeName )

                        && ( propCode == EMTPObjectPropCodeDateAdded ) ) )

                    {

                    TRAP( err, iDpConfig.GetWrapperL().GetObjectMetadataValueL( propCode,

                        *textData,

                        aObject ) );

                    if ( err == KErrNone )

                        {

                        }

                    else if ( err == KErrNotFound )

                        {

                        iPropertyElement = NULL;

                        }

                    else

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

                    }

                break;

            default:

                {

                ServiceGetSpecificObjectPropertyL( propCode, handle, aObject );

                }

                break;

            }

            {

            iPropertyList->CommitPropElemL( *iPropertyElement );

            iPropertyElement = NULL;

            }

        } // end of for loop

    PRINT1( _L( "MM MTP <= CMoveObject::GetPreviousPropertiesL err = %d" ), err );

    }

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

// CMoveObject::SetPreviousPropertiesL

// Set the object properties after doing the move

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

//

    {

    PRINT( _L( "MM MTP => CMoveObject::SetPreviousPropertiesL" ) );

    TMTPResponseCode respcode = EMTPRespCodeOK;

    iPropertyList->ResetCursor();

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

        {

        switch ( propertyCode )

            {

            case EMTPObjectPropCodeStorageID:

            case EMTPObjectPropCodeObjectFormat:

            case EMTPObjectPropCodeProtectionStatus:

            case EMTPObjectPropCodeObjectSize:

            case EMTPObjectPropCodeObjectFileName:

            case EMTPObjectPropCodeParentObject:

            case EMTPObjectPropCodePersistentUniqueObjectIdentifier:

            case EMTPObjectPropCodeDateCreated:

            case EMTPObjectPropCodeDateModified:

            case EMTPObjectPropCodeDateAdded:

                break;

            case EMTPObjectPropCodeName:

                {

                    *stringData,

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

                }

                break;

            default:

                {

                }

                break;

            }

        } // end of for loop

    PRINT1( _L( "MM MTP <= CMoveObject::SetPreviousPropertiesL respcode = 0x%x" ), respcode );

    }

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

// CMoveObject::SetPropertiesL

// Set the object properties in the object property store.

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

//

    {

    PRINT2( _L( "MM MTP => CMoveObject::SetPropertiesL aOldFileName = %S, aNewFileName = %S" ),

    if ( formatCode == EMTPFormatCodeAbstractAudioVideoPlaylist )

        {

        PRINT( _L( "MM MTP <> CMoveObject::SetPropertiesL Playlist file do not update the MPX DB" ) );

        }

    else

        {

        if ( iSameStorage )

            iDpConfig.GetWrapperL().RenameObjectL( aOldFileName, aNewFileName );

        else

            {

            iDpConfig.GetWrapperL().DeleteObjectL( aOldFileName, formatCode );