// 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 <pathinfo.h> // PathInfo

#include <sysutil.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 "cmtpimagedpcopyobject.h"

#include "mtpimagedppanic.h"

#include "mtpimagedputilits.h"

#include "cmtpimagedp.h"

const TInt RollbackFuncCnt = 1;

/**

Verification data for the CopyObject request

*/

const TMTPRequestElementInfo KMTPCopyObjectPolicy[] = 

    {

        {TMTPTypeRequest::ERequestParameter2, EMTPElementTypeStorageId, EMTPElementAttrWrite, 0, 0, 0},

        {TMTPTypeRequest::ERequestParameter3, EMTPElementTypeObjectHandle, EMTPElementAttrDir, 1, 0, 0}

    };

/**

Two-phase construction method

@param aPlugin	The data provider plugin

@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* CMTPImageDpCopyObject::NewL(MMTPDataProviderFramework& aFramework, MMTPConnection& aConnection,CMTPImageDataProvider& aDataProvider)

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

/**

Destructor

*/	

CMTPImageDpCopyObject::~CMTPImageDpCopyObject()

    {	

    delete iDest;

    delete iFileMan;

    delete iSrcObjectInfo;

    delete iTargetObjectInfo;

    iRollbackActionL.Close();

    }

/**

Standard c++ constructor

*/	

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

    CMTPRequestProcessor(aFramework, aConnection, sizeof(KMTPCopyObjectPolicy)/sizeof(TMTPRequestElementInfo), KMTPCopyObjectPolicy),

    iFramework(aFramework),

    iDataProvider(aDataProvider)

    {

    }

/**

Second phase constructor

*/

void CMTPImageDpCopyObject::ConstructL()

    {

    iFileMan = CFileMan::NewL(iFramework.Fs());

    iSrcObjectInfo = CMTPObjectMetaData::NewL();

    iRollbackActionL.ReserveL(RollbackFuncCnt);

    }

TMTPResponseCode CMTPImageDpCopyObject::CheckRequestL()

    {

    TMTPResponseCode responseCode = CMTPRequestProcessor::CheckRequestL();

    if (EMTPRespCodeOK == responseCode)

        {

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

        // Check whether object handle is valid

        responseCode = MTPImageDpUtilits::VerifyObjectHandleL(iFramework, objectHandle, *iSrcObjectInfo);

        }

    else if(EMTPRespCodeInvalidObjectHandle == responseCode) //we only check the parent handle

        {

        responseCode = EMTPRespCodeInvalidParentObject;

        }

    return responseCode;

    }

/**

CopyObject request handler

*/      

void CMTPImageDpCopyObject::ServiceL()

    {   

    TUint32 handle = KMTPHandleNone;

    TMTPResponseCode responseCode = CopyObjectL(handle);

    if(responseCode == EMTPRespCodeOK)

        {

        SendResponseL(EMTPRespCodeOK, 1, &handle);

        }

    else

        {

        SendResponseL(responseCode);

        }

    }

/**

Copy object operation

@return the object handle of the resulting object.

*/

TMTPResponseCode CMTPImageDpCopyObject::CopyObjectL(TUint32& aNewHandle)

    {

    TMTPResponseCode responseCode = EMTPRespCodeOK;

    aNewHandle = KMTPHandleNone;

    GetParametersL();

    iNewFileName.Append(*iDest);

    const TDesC& oldFileName = iSrcObjectInfo->DesC(CMTPObjectMetaData::ESuid);

    TParsePtrC fileNameParser(oldFileName);

    if((iNewFileName.Length() + fileNameParser.NameAndExt().Length()) <= iNewFileName.MaxLength())

        {

        iNewFileName.Append(fileNameParser.NameAndExt());

        responseCode = CanCopyObjectL(oldFileName, iNewFileName);	

        }

    else

        {

        responseCode = EMTPRespCodeGeneralError;

        }

    if(responseCode == EMTPRespCodeOK)

        {

        aNewHandle = CopyFileL(oldFileName, iNewFileName);

        }

    return responseCode;

    }

/**

A helper function of CopyObjectL.

@param aNewFileName the new full filename after copy.

@return objectHandle of new copy of object.

*/

TUint32 CMTPImageDpCopyObject::CopyFileL(const TDesC& aOldFileName, const TDesC& aNewFileName)

    {

    TCleanupItem anItem(FailRecover, reinterpret_cast<TAny*>(this));

    CleanupStack::PushL(anItem);

    GetPreviousPropertiesL(aOldFileName);

    iRollbackActionL.AppendL(RollBackFromFsL);

    SetPreviousPropertiesL(aNewFileName);

    iFramework.ObjectMgr().InsertObjectL(*iTargetObjectInfo);

    //check object whether it is a new image object

    if (MTPImageDpUtilits::IsNewPicture(*iTargetObjectInfo))

        {

        //increate new pictures count

        iDataProvider.IncreaseNewPictures(1);

        }    

    CleanupStack::Pop(this);

    return iTargetObjectInfo->Uint(CMTPObjectMetaData::EHandle);

    }

/**

Retrieve the parameters of the request

*/	

void CMTPImageDpCopyObject::GetParametersL()

    {

    __ASSERT_DEBUG(iRequestChecker, Panic(EMTPImageDpRequestCheckNull));

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

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

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

    if(parentObjectHandle == 0)

        {

        SetDefaultParentObjectL();

        }

    else	

        {

        CMTPObjectMetaData* parentObjectInfo = iRequestChecker->GetObjectInfo(parentObjectHandle);

        __ASSERT_DEBUG(parentObjectInfo, Panic(EMTPImageDpObjectNull));

        delete iDest;

        iDest = NULL;

        iDest = parentObjectInfo->DesC(CMTPObjectMetaData::ESuid).AllocL();        

        iNewParentHandle = parentObjectHandle;

        }

    }

/**

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

*/

void CMTPImageDpCopyObject::SetDefaultParentObjectL()

    {

    TDriveNumber drive(static_cast<TDriveNumber>(iFramework.StorageMgr().DriveNumber(iStorageId)));

    TChar driveLetter;

    iFramework.Fs().DriveToChar(drive, driveLetter);

    TFileName driveBuf;

    driveBuf.Append(driveLetter);

    driveBuf = BaflUtils::RootFolderPath(driveBuf.Left(1));

    delete iDest;

    iDest = NULL;

    iDest = driveBuf.AllocL();

    iNewParentHandle = KMTPHandleNoParent;

    }

/**

Check if we can copy the file to the new location

*/

TMTPResponseCode CMTPImageDpCopyObject::CanCopyObjectL(const TDesC& aOldName, const TDesC& aNewName) const

    {

    TMTPResponseCode result = EMTPRespCodeOK;

    TEntry fileEntry;

    TDriveNumber drive(static_cast<TDriveNumber>(iFramework.StorageMgr().DriveNumber(iStorageId)));

    TVolumeInfo volumeInfo;

    if(volumeInfo.iFree < fileEntry.FileSize())

        {

        result = EMTPRespCodeStoreFull;

        }

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

        {

        result = EMTPRespCodeInvalidParentObject;

        }

    return result;	

    }

/**

Save the object properties before doing the copy

*/

void CMTPImageDpCopyObject::GetPreviousPropertiesL(const TDesC& aOldFileName)

    {

    }

/**

Set the object properties after doing the copy

*/

void CMTPImageDpCopyObject::SetPreviousPropertiesL(const TDesC& aNewFileName)

    {

    iTargetObjectInfo = CMTPObjectMetaData::NewL();

    iTargetObjectInfo->SetUint(CMTPObjectMetaData::EDataProviderId, iSrcObjectInfo->Uint(CMTPObjectMetaData::EDataProviderId));

    iTargetObjectInfo->SetUint(CMTPObjectMetaData::EFormatCode, iSrcObjectInfo->Uint(CMTPObjectMetaData::EFormatCode));

    iTargetObjectInfo->SetUint(CMTPObjectMetaData::EFormatSubCode, iSrcObjectInfo->Uint(CMTPObjectMetaData::EFormatSubCode));

    iTargetObjectInfo->SetDesCL(CMTPObjectMetaData::EName, iSrcObjectInfo->DesC(CMTPObjectMetaData::EName));

    iTargetObjectInfo->SetUint(CMTPObjectMetaData::ENonConsumable, iSrcObjectInfo->Uint(CMTPObjectMetaData::ENonConsumable));

    iTargetObjectInfo->SetUint(CMTPObjectMetaData::EParentHandle, iNewParentHandle);

    iTargetObjectInfo->SetUint(CMTPObjectMetaData::EStorageId, iStorageId);

    iTargetObjectInfo->SetDesCL(CMTPObjectMetaData::ESuid, aNewFileName);

    }

void CMTPImageDpCopyObject::FailRecover(TAny* aCopyOperation)

    {

    reinterpret_cast<CMTPImageDpCopyObject*>(aCopyOperation)->RollBack();

    }

void CMTPImageDpCopyObject::RollBack()

    {

    TInt i = iRollbackActionL.Count();

    while(-- i >= 0)

        {

        TRAP_IGNORE((*iRollbackActionL[i])(this));

        }

    iRollbackActionL.Reset();

    }

void CMTPImageDpCopyObject::RollBackFromFsL()

    {

    }

void CMTPImageDpCopyObject::RollBackFromFsL(CMTPImageDpCopyObject* aObject)

    {

    aObject->RollBackFromFsL();

    }

// End of file