/*

* 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 <cs_port.h>

#include "AcmReader.h"

#include "AcmUtils.h"

#include "ActiveReader.h"

#include "ActiveReadOneOrMoreReader.h"

#include "CdcAcmClass.h"

#include "AcmPanic.h"

#include "AcmPort.h"

CAcmReader* CAcmReader::NewL(CAcmPort& aPort,

							 TUint aBufSize)

/**

 * Factory function.

 *

 * @param aPort The CAcmPort parent.

 * @param aBufSize The size of the buffer.

 * @return Ownership of a new CAcmReader.

 */

	{

	CAcmReader* self = new(ELeave) CAcmReader(aPort, aBufSize);

	CleanupStack::PushL(self);

	self->ConstructL();

	CLEANUPSTACK_POP(self);

	return self;

	}

CAcmReader::~CAcmReader()

/**

 * Destructor.

 */

	{

	ReadCancel();

	delete iBuffer;

	}

CAcmReader::CAcmReader(CAcmPort& aPort,

					   TUint aBufSize)

/**

 * Constructor.

 *

 * @param aPort The CPort parent.

 * @param aBufSize The size of the buffer.

 */

 :	iBufSize(aBufSize),

	iInBuf(NULL,0,0),

	iPort(aPort)

	{

	}

void CAcmReader::ConstructL()

/**

 * 2nd-phase construction.

 */

	{

	// Create iBuffer. 

	}

void CAcmReader::Read(const TAny* aClientBuffer, TUint aMaxLen)

/**

 * Read API.

 *

 * @param aClientBuffer Pointer to the client's memory space.

 * @param aMaxLen Maximum length to read.

 */

	{

	// Check we're open to requests and make a note of interesting data.

	// including iLengthToGo

	CheckNewRequest(aClientBuffer, aMaxLen);

	iCurrentRequest.iRequestType = ERead;

	// A read larger than our internal buffer limit will result in us doing

	// multiple reads to the ports below. 

	// We used to just refuse the request with a KErrNoMemory.

	if ( iTerminatorCount == 0 )

		{

		ReadWithoutTerminators();

		}

	else

		{

		ReadWithTerminators();

		}

	}

void CAcmReader::ReadWithoutTerminators()

/**

 * Process a read request given that no terminator characters are set.

 */

	{

	// Can we complete immediately from the buffer?

	const TUint bufLen = BufLen();

	if ( iLengthToGo <= bufLen )

		{

		WriteBackData(iLengthToGo);

		CompleteRequest(KErrNone);

		return;

		}

	// There isn't enough in the buffer to complete the request, so we write 

	// back as much as we have, and issue a Read for more.

	if ( bufLen )

		{

		// Write back as much data as we've got already.

		WriteBackData(bufLen);

		}

	// Issue a read for the data we still need. 

	IssueRead();

	}

void CAcmReader::ReadWithTerminators()

/**

 * Process a read request given that terminator characters are set.

 */

	{

	// Can we complete immediately from the buffer? Search the buffer we have 

	// for any terminators. If found, complete back to the client. If not 

	// found, start issuing ReadOneOrMores until we either find one or run out 

	// of client buffer.

	const TUint bufLen = BufLen();

	if ( bufLen )

		{

		CheckForBufferedTerminatorsAndProceed();

		return;

		}

	// There's no buffered data. Get some.

	IssueReadOneOrMore();

	}

void CAcmReader::ReadOneOrMore(const TAny* aClientBuffer, TUint aMaxLen)

/**

 * ReadOneOrMore API. Note that this is implemented to completely ignore 

 * terminator characters.

 *

 * @param aClientBuffer Pointer to the client's memory space.

 * @param aMaxLen Maximum length to read.

 */

	{

	// Check we're open to requests and make a note of interesting data.

	CheckNewRequest(aClientBuffer, aMaxLen);

	// Check to see if there's anything in our buffer- if there is, we can 

	// complete immediately.

	const TUint bufLen = BufLen();

	if ( bufLen )

		{

		// Complete request with what's in the buffer

		WriteBackData(bufLen);

		CompleteRequest(KErrNone);

		return;

		}

	// Get some more data.

	IssueReadOneOrMore();

	}

void CAcmReader::NotifyDataAvailable()

/** 

 * NotifyDataAvailable API. If a request is pending completes the client with KErrInUse.

 */

	{

	if(iCurrentRequest.iClientPtr) // a request is pending

		{

		iPort.NotifyDataAvailableCompleted(KErrInUse);

		return;

		}

	iCurrentRequest.iClientPtr = iBuffer;

	iCurrentRequest.iRequestType = ENotifyDataAvailable;	 	

	iPort.Acm()->NotifyDataAvailable(*this);		

	} 

void CAcmReader::NotifyDataAvailableCancel()

/**

 * NotifyDataAvailableCancel API. Issues a ReadCancel() to abort pending requests on the LDD  

 *

 */

	{

	if (ENotifyDataAvailable == iCurrentRequest.iRequestType)

		{

		// Cancel any outstanding request on the LDD.		

		if (iPort.Acm())

			{

			iPort.Acm()->NotifyDataAvailableCancel();

			}

		// Reset our flag to say there's no current outstanding request. What's 

		// already in our buffer can stay there.

		iCurrentRequest.iClientPtr = NULL;

		}	

	}

void CAcmReader::ReadCancel()

/**

 * Cancel API. Cancels any outstanding (Read or ReadOneOrMore) request.

 */

	{

	if (ENotifyDataAvailable != iCurrentRequest.iRequestType)

		{

		// Cancel any outstanding request on the LDD.

		if (iPort.Acm())

			{

			iPort.Acm()->ReadCancel();

			}

		// Reset our flag to say there's no current outstanding request. What's 

		// already in our buffer can stay there.

		iCurrentRequest.iClientPtr = NULL;

		}

	}

TUint CAcmReader::BufLen() const

/**

 * This function returns the amount of data (in bytes) still remaining in the 

 * circular buffer.

 *

 * @return Length of data in buffer.

 */

	{

	TUint len = 0;

	if ( BufWrap() )

		{

		len = iBufSize - ( iOutPtr - iInPtr );

		}

	else

		{

		len = iInPtr - iOutPtr;

		}

	return len;

	}

void CAcmReader::ResetBuffer()

/**

 * Called by the port to clear the buffer.

 */

	{

	// A request is outstanding- C32 should protect against this.

	// Reset the pointers. All data is 'lost'.

	iOutPtr = iInPtr = iBufStart;

	}

TInt CAcmReader::SetBufSize(TUint aSize)

/**

 * Called by the port to set the buffer size. Also used as a utility by us to 

 * create the buffer at instantiation. Note that this causes what was in the 

 * buffer at the time to be lost.

 *

 * @param aSize The required size of the buffer.

 */

	{

	if ( iCurrentRequest.iClientPtr )

		{

		// A request is outstanding. C32 does not protect us against this.

		return KErrInUse;

		}

	// Create the new buffer.

	HBufC8* newBuf = HBufC8::New(aSize);

	if ( !newBuf )

		{

		return KErrNoMemory;

		}

	delete iBuffer;

	iBuffer = newBuf;

	// Update pointers etc.

	TPtr8 ptr = iBuffer->Des();

	iBufStart = const_cast<TUint8*>(reinterpret_cast<const TUint8*>(ptr.Ptr()));

	iBufSize = aSize;

	CheckBufferEmptyAndResetPtrs();

	return KErrNone;

	}

void CAcmReader::SetTerminators(const TCommConfigV01& aConfig)

/**

 * API to change the terminator characters.

 *

 * @param aConfig The new configuration.

 */

	{

	// C32 protects the port against having config set while there's a request 

	// outstanding.

	iTerminatorCount = aConfig.iTerminatorCount;

	for ( TUint ii = 0; ii < static_cast<TUint>(KConfigMaxTerminators) ; ii++ )

		{

		iTerminator[ii] = aConfig.iTerminator[ii];

		}

	}

void CAcmReader::ReadCompleted(TInt aError)

/**

 * Called by lower classes when an LDD Read completes. 

 *

 * @param aError Error.

 */

	{

	const TUint justRead = static_cast<TUint>(iInBuf.Length());

	// This protects against a regression in the LDD- read requests shouldn't 

	// ever complete with zero bytes and KErrNone.

	if ( justRead == 0 && aError == KErrNone )

		{

		}

	// The new data will have been added to our buffer. Move iInPtr up by the 

	// length just read.

	iInPtr += justRead;

	if ( aError )

		{

		// If the read failed, we complete back to the client and don't do 

		// anything more. (We don't want to get into retry strategies.) In a 

		// multi-stage Read the client will get any data already written back 

		// to them with IPCWrite.

		CompleteRequest(aError);

		return;

		}

	// calling this will write the data to the clients address space

	// it will also complete the request if we've given the client enough data

	// or will reissue another read if not

	ReadWithoutTerminators();

	}

void CAcmReader::ReadOneOrMoreCompleted(TInt aError)

/**

 * Called by lower classes when an LDD ReadOneOrMore completes. 

 *

 * @param aError Error.

 */

	{

	const TUint justRead = static_cast<TUint>(iInBuf.Length());

	// The new data will have been added to our buffer. Move iInPtr 

	// up by the length just read.

	iInPtr += justRead;

	if ( aError )

		{

		// If the ReadOneOrMore failed, we complete back to the client and 

		// don't do anything more. The client will get any data already 

		// written back to them with IPCWrite.

		CompleteRequest(aError);

		return;

		}

	// TODO: may the LDD complete ROOM with zero bytes, eg if a ZLP comes in?

	// NB The LDD is at liberty to complete a ReadPacket request with zero 

	// bytes and KErrNone, if the given packet was zero-length (a ZLP). In 

	// this case, we have to reissue the packet read until we do get some 

	// data. 

	if ( justRead == 0 )

		{

		IssueReadOneOrMore();

		return;

		}

	if ( EReadOneOrMore == iCurrentRequest.iRequestType )

		{

		// Complete the client's request with as much data as we can. NB 

		// Opinion may be divided over whether to do this, or complete with 

		// just 1 byte. We implement the more generous approach.

		WriteBackData(justRead);

		CompleteRequest(KErrNone);

		}

	else

		{

		// Outstanding request is a Read with terminators. (Except for 

		// ReadOneOrMore, we only request LDD::ReadOneOrMore in this case.)