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

 @internalComponent

*/

#include <f32file.h>

#include "obexasyncfilewriter.h"

#include "logger.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, "OBEX");

#endif

//

// Panic category for CObexAsyncFileWriter

//

_LIT(KObexAsyncFileWriterPanic, "Obex-AFW");

/**

Panic codes for CObexAsyncFileWriter

@internalComponent

@released

*/

enum TAsyncObexFileWriterPanic

	{

	/** Null buffer pointer */

	ENullBufferPointer

	};

//

// Implementation of CObexAsyncFileWriter

//

/**

Factory function

Note that we return a pointer to the interface class, so

that this class can only be used through this interface.

This class in an implementation of a strategy as part of

a Strategy pattern.  CObexSyncFileWriter provides an

alternative strategy implementation, with CObexBufObject

as the context for these strategies.

@see MObexFileWriter

@see CObexSyncFileWriter

@see CObexBufObject

@internalComponent

@released

@param aFile The file we're writing to

@return An MObexFileWriter for writing to file

*/

MObexFileWriter* CObexAsyncFileWriter::NewL(RFile& aFile)

	{

	CObexAsyncFileWriter* self = new(ELeave) CObexAsyncFileWriter(aFile);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/**

Constructor

@internalComponent

@released

@param aFile The file we're writing to

*/

CObexAsyncFileWriter::CObexAsyncFileWriter(RFile& aFile)

	: CActive(EPriorityStandard), iFile(aFile), iBufPtr(NULL, 0)

	{

	CActiveScheduler::Add(this);

	}

/**

2nd phase constructor

@internalComponent

@released

*/	

void CObexAsyncFileWriter::ConstructL()

	{

	}

/**

AO cancellation

@internalComponent

@released

*/

void CObexAsyncFileWriter::DoCancel()

	{

	iFile.Flush();

	}

/**

AO request completion

@internalComponent

@released

*/

void CObexAsyncFileWriter::RunL()

	{

	// Just ignore completions; the status is picked up next time

	// a service function is called

	}

/**

Normal asynchronous write to file

@internalComponent

@released

@param aPos The file position

@param aBuf The buffer we're to write. We use this buffer by copying the pointer

            and return the buffer we previously wrote to the caller by updating

            the pointer.  If an error occurs, the buffers are not swapped and

            the pointer is not updated.  Note that this class never owns any

            buffers and that passing a buffer to this function does not imply a

            transfer of ownership.

@return Symbian OS error code

*/

TInt CObexAsyncFileWriter::Write(TInt aPos, CBufBase*& aBuf)

	{

	__ASSERT_ALWAYS(aBuf, PANIC(KObexAsyncFileWriterPanic, ENullBufferPointer));

	// If last write to file has not completed...

	if (IsActive())

		{

		// wait for it to complete

		User::WaitForRequest(iStatus);

		// if we had an error on the last write

		if (iStatus.Int())

			{

			// Signal ourselves again with the error

			TRequestStatus* status = &iStatus;

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

			// and then de-activate ourselves by cancelling

			Cancel();

			}

		// if we didn't have an error on the last write,

		// we've consumed the completion of the write and

		// hence are still active

		}

	if (!iStatus.Int())

	// if the last write completed successfully...

		{

		// Swap our and the caller's pointers to show we

		// have swapped which buffers we are using.  Note

		// that the ownership of the buffers is not changed

		// by this and the caller must deallocate any buffers

		// it owns which are passed to this function.

		CBufBase* buf = iBuffer;

		iBuffer = aBuf;

		aBuf = buf;

		// Set up the descriptor to be passed to the file write

		iBufPtr.Set(iBuffer->Ptr(0));

		// We'll need to be active to service another write

		if (!IsActive())

			{

			SetActive();

			}

		// kick off writing the next block

		iFile.Write(aPos, iBufPtr, iStatus);

		// and we're happy...

		return KErrNone;

		}

	else

	// the last write did not complete successfully

		{

		// Signal Obex error

		return iStatus.Int();

		}

	}

/**

Final, synchronous write to file

@internalComponent

@released

@param aPos The file position

@param aBuf The buffer we're to write. We use this buffer by copying the pointer

            and return the buffer we previously wrote to the caller by updating

            the pointer.  If an error occurs, the buffers are not swapped and

            the pointer is not updated.  Note that this class never owns any

            buffers and that passing a buffer to this function does not imply a

            transfer of ownership.

@param aLength The amount of the buffer to write

@return Symbian OS error code

*/

TInt CObexAsyncFileWriter::FinalWrite(TInt aPos, CBufBase*& aBuf, TInt aLength)

	{

	__ASSERT_ALWAYS(aBuf, PANIC(KObexAsyncFileWriterPanic, ENullBufferPointer));

	// If last write to file has not completed...

	if (IsActive())

		{

		// wait for it to complete

		User::WaitForRequest(iStatus);

		// Signal ourselves again with the request status

		TRequestStatus* status = &iStatus;

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

		// and then de-activate ourselves by cancelling

		Cancel();

		}

	// if the last write completed successfully...

	if (!iStatus.Int())

		{

		// Swap our and the caller's pointers to show we

		// have swapped which buffers we are using.  Note

		// that the ownership of the buffers is not changed

		// by this and the caller must deallocate any buffers

		// it owns which are passed to this function.

		CBufBase* buf = iBuffer;

		iBuffer = aBuf;

		aBuf = buf;

		// Set up the descriptor to be passed to the file write

		iBufPtr.Set(iBuffer->Ptr(0));

		iBufPtr.SetLength(aLength);

		// write the final block and return the error

		TInt err = iFile.Write(aPos, iBufPtr);

		if (err == KErrNone)

			{

			//flush the buffer, commit the write

			return iFile.Flush();

			}

		else

			{

			return err;

			}

		}

	else

	// the last write did not complete successfully

		{	

		// Signal Obex error

		return iStatus.Int();

		}

	}

/**

Destructor

@internalComponent

@released

*/

CObexAsyncFileWriter::~CObexAsyncFileWriter()

	{

	Cancel();

	}