// Copyright (c) 2007-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:

//

#include <f32file.h>

#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 "cmtpfsentrycache.h"

#include "cmtpstoragemgr.h"

#include "cmtpmoveobject.h"

#include "mtpdppanic.h"

/**

Verification data for the MoveObject request

*/    

const TMTPRequestElementInfo KMTPMoveObjectPolicy[] = 

    {

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

        {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

*/     

EXPORT_C MMTPRequestProcessor* CMTPMoveObject::NewL(MMTPDataProviderFramework& aFramework, MMTPConnection& aConnection)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);	

	return self;

	}

/**

Destructor

*/	

EXPORT_C CMTPMoveObject::~CMTPMoveObject()

	{

	Cancel();

	iDpSingletons.Close();

	iSingletons.Close();

	delete iTimer;

	delete iNewFileName;

	delete iDest;

	delete iFileMan;

	delete iPathToMove;

	delete iNewRootFolder;	

	}

/**

Standard c++ constructor

*/	

CMTPMoveObject::CMTPMoveObject(MMTPDataProviderFramework& aFramework, MMTPConnection& aConnection) :

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

	iMoveObjectIndex(0), iTimer(NULL)

	{

	}

TMTPResponseCode CMTPMoveObject::CheckRequestL()

	{

	TMTPResponseCode result = CMTPRequestProcessor::CheckRequestL();

	if (EMTPRespCodeOK != result)

		{

		return result;

		}

	const TUint32 KObjectHandle = Request().Uint32(TMTPTypeRequest::ERequestParameter1);

	//not taking owernship

	iObjectInfo = iRequestChecker->GetObjectInfo(KObjectHandle); 

	__ASSERT_DEBUG(iObjectInfo, Panic(EMTPDpObjectNull));	

	if(!iSingletons.StorageMgr().IsReadWriteStorage(iObjectInfo->Uint(CMTPObjectMetaData::EStorageId)))

		{

		result = EMTPRespCodeStoreReadOnly;

		}

	if ( (EMTPRespCodeOK == result) && (!iSingletons.StorageMgr().IsReadWriteStorage(Request().Uint32(TMTPTypeRequest::ERequestParameter2))) )

		{

		result = EMTPRespCodeStoreReadOnly;

		}

	if(result == EMTPRespCodeOK)

		{

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

		iIsFolder = EFalse;

		if(!iIsFolder)

			{

			if(iDpSingletons.MovingBigFileCache().IsOnGoing())

				{

				result = EMTPRespCodeAccessDenied;

				}

			}

		}

	return result;	

	} 

/**

MoveObject request handler

*/		

void CMTPMoveObject::ServiceL()

	{

	TMTPResponseCode ret = EMTPRespCodeOK;

	TRAPD(err, ret = MoveObjectL());

	if (err != KErrNone)

		{

		SendResponseL(EMTPRespCodeAccessDenied);

		}

	else if (EMTPRespCodeOK != ret)

		{

		SendResponseL(ret);

		}

	}

/**

 Second phase constructor

*/

void CMTPMoveObject::ConstructL()

    {

	iSingletons.OpenL();

	iDpSingletons.OpenL(iFramework);

    }

/**

A helper function of MoveObjectL.

@param aNewFileName the new file name after the object is moved.

*/

void CMTPMoveObject::MoveFileL(const TDesC& aNewFileName)	

	{

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

	GetPreviousPropertiesL(suid);

	if(iFramework.StorageMgr().DriveNumber(iObjectInfo->Uint(CMTPObjectMetaData::EStorageId)) ==

			iFramework.StorageMgr().DriveNumber(iStorageId))

		//Move file to the same storage

		{

		SetPreviousPropertiesL(aNewFileName);

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

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

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

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

		SendResponseL(EMTPRespCodeOK);

		}

	else

		//Move file between different storages

		{

		delete iNewFileName;

		iNewFileName = NULL;

		iNewFileName = aNewFileName.AllocL(); // Store the new file name

		if ( !IsActive() )

		{  

		SetActive();

		}

		delete iTimer;

		iTimer = NULL;

		iTimer = CPeriodic::NewL(EPriorityStandard);

		TTimeIntervalMicroSeconds32 KMoveObjectIntervalNone = 0;	

		iTimer->Start(TTimeIntervalMicroSeconds32(KMoveObjectTimeOut), KMoveObjectIntervalNone, TCallBack(CMTPMoveObject::OnTimeoutL, this));		

		}

	}

/**

A helper function of MoveObjectL.

@param aNewFolderName the new file folder name after the folder is moved.

*/

void CMTPMoveObject::MoveFolderL()

	{

	RBuf oldFolderName;

	oldFolderName.CreateL(KMaxFileName);

	oldFolderName.CleanupClosePushL();

	oldFolderName = iObjectInfo->DesC(CMTPObjectMetaData::ESuid);

	iPathToMove = oldFolderName.AllocL();

	if (iObjectInfo->Uint(CMTPObjectMetaData::EDataProviderId) == iFramework.DataProviderId())

		{

		GetPreviousPropertiesL(oldFolderName);

		// Remove backslash.

		oldFolderName.SetLength(oldFolderName.Length() - 1);	

		SetPreviousPropertiesL(*iNewRootFolder);

		_LIT(KBackSlash, "\\");

		oldFolderName.Append(KBackSlash);	

		iObjectInfo->SetDesCL(CMTPObjectMetaData::ESuid, *iNewRootFolder);

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

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

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

		}

	CleanupStack::PopAndDestroy(); // oldFolderName.

	}

/**

move object operations

@return A valid MTP response code.

*/

TMTPResponseCode CMTPMoveObject::MoveObjectL()

	{

	TMTPResponseCode responseCode = EMTPRespCodeOK;

	GetParametersL();

	RBuf newObjectName;

	newObjectName.CreateL(KMaxFileName);

	newObjectName.CleanupClosePushL();

	newObjectName = *iDest;

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

	TParsePtrC fileNameParser(suid);

	// Check if the object is a folder or a file.

	if(!iIsFolder)

		{

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

			{

			newObjectName.Append(fileNameParser.NameAndExt());

			}

		responseCode = CanMoveObjectL(suid, newObjectName);			

		}

	else // It is a folder.

		{

		TFileName rightMostFolderName;		

		if((newObjectName.Length() + rightMostFolderName.Length() + 1) <= newObjectName.MaxLength())

			{

			newObjectName.Append(rightMostFolderName);

			// Add backslash.

			_LIT(KBackSlash, "\\");

			newObjectName.Append(KBackSlash);

			}

		}

	iNewRootFolder = newObjectName.AllocL();

	if(responseCode == EMTPRespCodeOK)

		{			

		delete iFileMan;

		iFileMan = NULL;

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

		if(!iIsFolder)

			{

			MoveFileL(newObjectName);

			}

		else

			{		

			MoveFolderL();

			SendResponseL(responseCode);

			}

		}

	CleanupStack::PopAndDestroy(); // newObjectName.

	return responseCode;

	}

/**

Retrieve the parameters of the request

*/	

void CMTPMoveObject::GetParametersL()

	{

	__ASSERT_DEBUG(iRequestChecker, Panic(EMTPDpRequestCheckNull));

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

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

	if(iNewParentHandle == 0)

		{

		SetDefaultParentObjectL();

		}

	else	

		{

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

		__ASSERT_DEBUG(parentObjectInfo, Panic(EMTPDpObjectNull));

		delete iDest;

		iDest = NULL;

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

		}

	}

/**

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

*/

void CMTPMoveObject::SetDefaultParentObjectL()

	{

	const CMTPStorageMetaData& storageMetaData( iFramework.StorageMgr().StorageL(iStorageId) );

	const TDesC& driveBuf( storageMetaData.DesC(CMTPStorageMetaData::EStorageSuid) );

	delete iDest;

	iDest = NULL;

	iDest = driveBuf.AllocL();

	iNewParentHandle = KMTPHandleNoParent;

	}

/**

Check if we can move the file to the new location

*/

TMTPResponseCode CMTPMoveObject::CanMoveObjectL(const TDesC& aOldName, const TDesC& aNewName) const

	{

	TMTPResponseCode result = EMTPRespCodeOK;

	TEntry fileEntry;

	TInt drive(iFramework.StorageMgr().DriveNumber(iStorageId));

	TVolumeInfo volumeInfo;

#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

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

#else

    if(volumeInfo.iFree < fileEntry.iSize)

#endif

		{

		result = EMTPRespCodeStoreFull;

		}

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

		{

		result = EMTPRespCodeInvalidParentObject;

		}

	return result;	

	}

/**

Save the object properties before moving

*/

void CMTPMoveObject::GetPreviousPropertiesL(const TDesC& aFileName)

	{

	}

/**

Set the object properties after moving

*/

void CMTPMoveObject::SetPreviousPropertiesL(const TDesC& aFileName)

	{

	}

/**

 Call back function, called when the timer expired for big file moving.

 Send response to initiator and cache the target file entry info, which is used to send response 

 to getobjectproplist and getobjectinfo.

*/

TInt CMTPMoveObject::OnTimeoutL(TAny* aPtr)

	{

	CMTPMoveObject* moveObjectProcessor = static_cast<CMTPMoveObject*>(aPtr);

	moveObjectProcessor->DoOnTimeoutL();

	return KErrNone;

	}

void CMTPMoveObject::DoOnTimeoutL()

	{

	if (iTimer)

		{

		if (iTimer->IsActive())

			{

			iTimer->Cancel();

			}

		delete iTimer;

		iTimer = NULL;

		}

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

	TEntry fileEntry;

	TUint32 handle = iObjectInfo->Uint(CMTPObjectMetaData::EHandle);

	iObjectInfo->SetDesCL(CMTPObjectMetaData::ESuid, *iNewFileName);

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

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

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

	CMTPFSEntryCache& aCache = iDpSingletons.MovingBigFileCache();

	// Cache the target file entry info, which is used to send response to getobjectproplist and getobjectinfo

	aCache.SetOnGoing(ETrue);

	aCache.SetTargetHandle(handle);

	aCache.SetFileEntry(fileEntry);	

	SendResponseL(EMTPRespCodeOK);

	}

/**

 CMTPMoveObject::RunL

*/

void CMTPMoveObject::RunL()

	{

	SetPreviousPropertiesL(*iNewFileName);

	CMTPFSEntryCache& aCache = iDpSingletons.MovingBigFileCache();

	// Check to see if we are moving a big file

	if(aCache.IsOnGoing())

		{

		aCache.SetOnGoing(EFalse);

		aCache.SetTargetHandle(KMTPHandleNone);

		}

	else

		{

		//Cancel the timer

		if(iTimer)

			{

			if(iTimer->IsActive())

				{