// Copyright (c) 1997-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 <e32std.h>

#include <mmf/server/mmfdatabuffer.h>

#include <mmf/common/mmfutilities.h>

#include <mmf/common/mmfcontroller.h>

#include <mmf/common/mmfpaniccodes.h>

#include "MmffilePriv.h"

#include "FileAccess.h"

void Panic(TMMFFilePanicCode aPanicCode)

	{

	_LIT(KMMFFilePanicCategory, "MMFFile");

	User::Panic(KMMFFilePanicCategory, aPanicCode);

	}

/**

 * Constructs a CTransferBufferCopy

 *

 * @return CTransferBufferCopy*

 */

CTransferBufferCopy* CTransferBufferCopy::NewL(TInt aMaxLength)

	{

	CTransferBufferCopy* self = new (ELeave) CTransferBufferCopy(aMaxLength);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/**

 * Second phase constructor for CTransferBufferCopy

 *

 * @return void

 */

void CTransferBufferCopy::ConstructL()

	{

	iBuffer = static_cast<TUint8*>(User::AllocL(iMaxLength));

	iBufferDes.Set(iBuffer,0,iMaxLength);

	}

/**

Destructor.

*/

CMMFFile::~CMMFFile() 

	{

	delete iFile;

	iHandle.Close();

	iFsSession.Close();

	delete iFileName;

	delete iFileExt;

	delete iFilePath;

	delete iFileDrive;

	delete iMmfFileEventHandler;

	delete iCAFParameters;

	// Get rid of everything in RArray's & close them.

	iRequests.ResetAndDestroy();

	iTransferBufferCopies.ResetAndDestroy();

	}

/**

Protected constructor.

The default implementation is empty.

*/

CMMFFile::CMMFFile() : CMMFClip( KUidMmfFileSource, KUidMmfFileSink ), iFileSize(-1)

	{

	iSinkNotStopped = EFalse;

	}

/**

Constructs an CMMFFile MDataSource.

@return A pointer to the new CMMFFile data source.

*/

MDataSource* CMMFFile::NewSourceL() 

	{

	CMMFFile* self = new (ELeave) CMMFFile ;

	return STATIC_CAST( MDataSource*, self ) ;

	}

/**

Constructs a CMMFFile MDataSink

@return A pointer to the new CMMFFile data sink.

*/

MDataSink* CMMFFile::NewSinkL()

	{

	CMMFFile* self = new (ELeave) CMMFFile ;

	return STATIC_CAST( MDataSink*, self ) ;

	}

/**

Perform source construction dependant on the source construction

initialisation data aInitData.

@param  aInitData

        The TPckg<TMMFFileParams> descriptor package containing the file name and full path.

*/

void CMMFFile::ConstructSourceL(const TDesC8& aInitData ) 

	{

	ConstructL(aInitData, ESourceMode);

	}

/**

Performs sink construction dependant on the sink construction

initialisation data aInitData.

@param  aInitData

        The TPckg<TMMFFileParams> descriptor package containing the file name and full path.

*/

void CMMFFile::ConstructSinkL(const TDesC8& aInitData)

	{

	ConstructL(aInitData, ESinkMode);

	}

/**

Protected constructor.

Extracts the initialisation data provided by the calling functions: ConstructSourceL() and 

ConstructSinkL(). Creates a file server session and sets up file name. If there is a file name and 

it cannot be found this function leaves. If there is no file name the function leaves. Does not 

attempt to open the file or check whether the file exists.

If aInitData contains a TMMFFileHandleParams instead of TMMFFileParams, the source/sink is constructed from 

the file handle provided by the caller

@param  aInitData

        Initialisation data packaged in a TMMFFileParams or in a TMMFFileHandleParams (File Handle)

*/

void CMMFFile::ConstructL(const TDesC8& aInitData,TMMFileMode aFileMode)

	{

	User::LeaveIfError(iFsSession.Connect());

#ifdef __IPC_V2_PRESENT__

	// on IPCv2 we auto attach

	User::LeaveIfError(iFsSession.ShareAuto());

#else

	// on IPCv1 we use explicit - more efficient

	User::LeaveIfError(iFsSession.Share(RSessionBase::EExplicitAttach));

#endif

	User::LeaveIfError(iFsSession.ShareProtected());

	HBufC* filename = NULL; 

	iCAFParameters = new (ELeave) CCAFParameters;

	TBool drmContent = EFalse;

	RDesReadStream stream(aInitData);

	CleanupClosePushL(stream);

	TUid initUid = TUid::Uid(stream.ReadInt32L());

	if (initUid == KMMFileHandleSourceUid)

		{

		TPckgBuf<RFile*> fileptr;

		stream.ReadL(fileptr);

		iHandle.Duplicate(*fileptr());

		TInt length = stream.ReadInt32L();

		if (length>0)

			{

			iCAFParameters->iUniqueId = HBufC::NewL(length);

			TPtr16 ptr = iCAFParameters->iUniqueId->Des();

			stream.ReadL(ptr, length);

			}

		iFileHandle = ETrue;

		filename = HBufC::NewMaxLC(KMaxFileName);

		TPtr ptr = filename->Des();

		User::LeaveIfError(iHandle.FullName(ptr));

		drmContent = ETrue;

		iCAFParameters->iEnableUI = stream.ReadInt32L();

		}

	else if (initUid == KMMFileSourceUid)

		{

		TInt length = stream.ReadInt32L();

		filename = HBufC::NewMaxLC(length);

		TPtr ptr = filename->Des();

		stream.ReadL(ptr, length);

		length = stream.ReadInt32L();

		if (length>0)

			{

			iCAFParameters->iUniqueId = HBufC::NewMaxL(length);

			ptr.Set(iCAFParameters->iUniqueId->Des());

			stream.ReadL(ptr, length);

			}

		drmContent = ETrue;

		iCAFParameters->iEnableUI = stream.ReadInt32L();

		}

	else

		{

//		TODO If the UID is unknown we should reject, but  currently

//		code also used for older calls that just supply filename.

//		User::Leave(KErrNotSupported);

		}

	if ((filename == NULL) && aInitData.Length() == sizeof(TMMFFileHandleParams))

		{

		TMMFFileHandleParams params;

		TPckgC<TMMFFileHandleParams> config(params);

		config.Set(aInitData);

		params = config();

		if (params.iUid == KFileHandleUid)

			{

			User::LeaveIfError(iHandle.Duplicate(*params.iFile));

			TInt pos = 0;

			// make sure the duplicate handle is at the start of the file - the usage of the file handle really requires this

			User::LeaveIfError(iHandle.Seek(ESeekStart, pos));

			iFileHandle = ETrue;

			ASSERT(filename == NULL);

			filename = HBufC::NewMaxLC(KMaxFileName);

			TPtr ptr = filename->Des();

			User::LeaveIfError(iHandle.FullName(ptr));

			}

		}

	if (filename == NULL) // do old case as last resort

		{

		TMMFFileParams params;

		TPckgC<TMMFFileParams> config(params);

		config.Set(aInitData);

		params = config();

		filename = params.iPath.AllocLC();

		}

	ASSERT(filename != NULL);

	TParse parser ;

	User::LeaveIfError(parser.Set(*filename, NULL, NULL));

	CleanupStack::PopAndDestroy(2, &stream); //filename, stream

	if ( !( parser.NamePresent() ) && !( parser.ExtPresent() ) )

		{

		User::Leave( KErrBadName ) ;

		}

	iFullFileName.Copy( parser.FullName() ) ;	

	iFileName = parser.Name().AllocL() ;

	iFileExt = parser.Ext().AllocL() ;

	iFilePath = parser.Path().AllocL() ;

	iFileDrive = parser.Drive().AllocL() ;

	// in order to simulate old behaviour we are not passing error out

	// but will try to create Content again during PrimeL()

	if (drmContent && aFileMode==ESourceMode)

		{

		TInt contentError;

		if (iFileHandle)

			{

			TRAP(contentError, 

				iFile = CContentFile::NewL(iHandle, UniqueId(), iCAFParameters->iEnableUI);

				);

			}

		else

			{

			// Open for read-only access

			TRAP(contentError,

				iFile = CContentFile::NewL(iFsSession, iFullFileName, UniqueId(), EFileShareReadersOnly, iCAFParameters->iEnableUI);

			);

			}

		}

	}

/**

@deprecated - Replaced by CMMFFile::Data()

Returns an RFile handle to the current file.

If there is no current file, one is created. If the file exists then it is opened with read access 

if it is read only, write access otherwise. If the file does not exist then it is opened with

write access.

@leave KErrNotReady

       The file is not open.

@return A handle to the current file.

@see CMMFFile::Data()

*/

RFile& CMMFFile::FileL()

	{

	if (!iFile)

		User::Leave(KErrNotReady);

	if (iFileHandle)

		return iHandle;

	else

		return iFile->FileL();

	}

/** 

Returns the file name of the current file.

Note: This will give the wrong answer if the file is renamed!

@return The FileName (without extension).

*/

const TDesC& CMMFFile::FileName() const

	{

	return *iFileName ;

	}

/**

Returns the extension of the current file.

Note: This will give the wrong answer if the file is renamed!

@return The File Extension.

*/

const TDesC& CMMFFile::Extension() const 

	{

	return *iFileExt ;

	}

/** 

Returns the path of the current file.

Note: This will give the wrong answer if the file is renamed!

@return The FilePath (without filename and extension)

*/

const TDesC& CMMFFile::FilePath() const 

	{

	return *iFilePath ;

	}

/** 

Returns the drive on which the current file is located.

Note: This will give the wrong answer if the file is renamed!

@return The FileDrive (drive letter only, without path, filename and extension).

*/

const TDesC& CMMFFile::FileDrive() const 

	{

	return *iFileDrive ;

	}

/** 

Returns the full name of the current file.

Note: This will give the wrong answer if the file is renamed!

@return The file name (full filename including drive letter, without path, filename and extension).

*/

const TFileName CMMFFile::FullName() const

	{

	return iFullFileName;

	}

/** 

Returns the uniqueID associated with this content. If no uniqueID has been provided, a null

descriptor will be provided

@return The UniqueID

*/

const TDesC& CMMFFile::UniqueId() const

	{

	if (iCAFParameters->iUniqueId)

		return *(iCAFParameters->iUniqueId);

	else

		return KNullDesC;

	}

/**

Deletes the file.

Closes the currently open file, then deletes it. If the file source is accessing a file handle, 

the file is truncated to 0 bytes instead.

@return An error code indicating if the function call was successful. KErrNone on success, otherwise

        another of the system-wide error codes.

*/

TInt CMMFFile::Delete()				

	{

	TInt result = KErrNone;

	if (!iFileHandle)

		{

		delete iFile;

		iFile = NULL;

		iFileSize=-1;

		iPosition=0;

		result = iFsSession.Delete(iFullFileName);

		}

	else

		{

		iFileSize=-1;

		iPosition=0;

		if (iFile)

			{

			result = iFile->SetSize(0);

			}

		}

	return result;

	}

/** 

Sets the file size.

@param  aSize

        The size of the file.

@return An error code indicating if the function call was successful. KErrNone on success, otherwise

        another of the system-wide error codes.

*/

TInt CMMFFile::SetSize(TInt aSize)

	{

	if ( !iFile )

		return KErrNotReady;

	TInt err =  iFile->SetSize(aSize);

	if(err == KErrNone)

		iFileSize = aSize;

	else

		iFileSize = -1;

	return err;

	}

/**

Obtains a CTransferBufferCopy from iTransferBufferCopies that is

at least as big as that required.

There is no need to put the pointer returned by this method onto the CleanupStack

as it will have already been placed into iTransferBufferCopies.

@param  aMaxLength

        The size required.

@return A pointer to a valid CTransferBufferCopy.

*/

CTransferBufferCopy* CMMFFile::ObtainCopyOfTransferBufferL(TInt aMaxLength)

	{

	//find a free transfer buffer copy of the right size

	TInt firstFree = -1;

	CTransferBufferCopy* transBufCopyToUse = NULL;

	for(TInt cnt=0; cnt < iTransferBufferCopies.Count(); cnt++)

		{

		if(!iTransferBufferCopies[cnt]->InUse())

			{

			//record the first free entry, we may remove this

			//if entries in iTransferBufferCopies > KAcceptableTransferBufferCopiesSize

			if(firstFree == -1) 

				firstFree = cnt;

			if(iTransferBufferCopies[cnt]->MaxLength() >= aMaxLength)

				{

				transBufCopyToUse = iTransferBufferCopies[cnt];

				//Set the MaxLength. This will ensure that the copy acts the same as

				//the original Transfer buffer, eg. file server will throw KErrOverflow

				transBufCopyToUse->ReUse(aMaxLength);

				break;

				}

			}

		}

	//If we failed to find a suitable entry, we need to create a new one

	if(!transBufCopyToUse)

		{

		//Firstly, should we re-cycle an existing entry?

		//There must be entries in the array, a free entry must have been found,

		//the size of the array must be beyond the water mark where we want to start

		//cycling free entries.

		if((iTransferBufferCopies.Count() > 0) &&

			(firstFree != -1) &&

			(iTransferBufferCopies.Count() > KAcceptableTransferBufferCopiesSize))

			{

			delete iTransferBufferCopies[firstFree];

			iTransferBufferCopies.Remove(firstFree);

			transBufCopyToUse = CTransferBufferCopy::NewL(aMaxLength);

			CleanupStack::PushL(transBufCopyToUse);

			User::LeaveIfError(iTransferBufferCopies.Insert(transBufCopyToUse,firstFree));

			CleanupStack::Pop();

			}

		else

			{

#ifdef _DEBUG

			if(iTransferBufferCopies.Count() > KMaximumTransferBufferCopiesSize)

				{

				User::Panic(_L("iTransferBufferCopies grew too large in CMMFFile"),KErrTooBig);

				}

#endif

			transBufCopyToUse = CTransferBufferCopy::NewL(aMaxLength);

			CleanupStack::PushL(transBufCopyToUse);

			User::LeaveIfError(iTransferBufferCopies.Append(transBufCopyToUse));

			CleanupStack::Pop();

			}

		}

	return transBufCopyToUse;

	}

/** 

Loads aBuffer from iFile.