// Copyright (c) 2002-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 "LogViewWindowFetcher.h"

// System includes

#include <s32mem.h>

// User includes

#include "logservcli.h"

// Constants

const TInt KLogSizeOfEventGuess = 200;

const TInt KLogWindowFetchBufferGranularity = KLogSizeOfEventGuess * 2;

const TInt KLogWindowFetchBufferMinimumBufferSize = 4;

/////////////////////////////////////////////////////////////////////////////////////////

// -----> CLogViewWindowFetcher (source)

/////////////////////////////////////////////////////////////////////////////////////////

CLogViewWindowFetcher::CLogViewWindowFetcher(RLogSession& aSession, TLogViewId aViewId, MLogViewWindowFetcherObserver& aObserver, TInt aPriority)

:	CActive(aPriority), iSession(aSession), iViewId(aViewId), iObserver(aObserver), iBufferPointer(NULL, 0)

	{

	CActiveScheduler::Add(this);

	iData().iOperationType = ELogOperationViewWindowFetch;

	}

CLogViewWindowFetcher::~CLogViewWindowFetcher()

	{

	Cancel();

	//

	delete iBuffer;

	}

void CLogViewWindowFetcher::ConstructL()

	{

	iBuffer = CBufFlat::NewL(KLogWindowFetchBufferGranularity);

	}

/////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////

void CLogViewWindowFetcher::PrepareToFetchWindowL(const TLogWindowAndCursor& aRequestedWindow)

	{

	iRequestedWindow = aRequestedWindow;

	iRequestedWindow.iValid = EFalse;

	iWindowReq = iRequestedWindow; // Initialise window

	// Setup the buffer so that its the right size to receive the events

	const TInt range = Max(1, iRequestedWindow.iUpper - iRequestedWindow.iLower + 1);

	const TInt size = KLogSizeOfEventGuess * range;

	iBuffer->ResizeL(size);

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

	//

	iFetchWindowData().iBufferSize = size;

	}

void CLogViewWindowFetcher::Start(TRequestStatus& aObserver)

	{

	iObserverRequestStatus = &aObserver;

	*iObserverRequestStatus = KRequestPending;

	if	(iRequestedWindow.Range())

		Fetch(iRequestedWindow);

	else

		{

		// Nothing to fetch

		iRequestedWindow.NormalizeWindowAndCursor();

		User::RequestComplete(iObserverRequestStatus, KErrNone);

		}

	}

void CLogViewWindowFetcher::SilentCancel()

	{

	if	(iObserverRequestStatus)

		User::RequestComplete(iObserverRequestStatus, KErrNone);

	Cancel();

	}

/////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////

void CLogViewWindowFetcher::RunL()

	{

	const TInt sentByServer = iStatus.Int();

	User::LeaveIfError(sentByServer);

	//The server has completed the operation without any error, but there is no returned data

	//(sentByServer == 0). Then the client has to check if iFetchWindowData().iServerDataSize

	//data member is set, which means that the server wants to send more data than the client

	//side buffer can accept. The client has to increase the buffer size and then execute 

	//the operation again.

	TInt newSize = iFetchWindowData().iServerDataSize;

	//newSize was initialized, so iFetchWindowData().iServerDataSize can be set to 0.

	iFetchWindowData().iServerDataSize = 0;

	if(sentByServer == 0 && newSize > 0)

		{

		iBuffer->ResizeL(newSize);

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

		iFetchWindowData().iBufferSize = newSize;

		//The operation will be executed again later - see "Fetch(iWindowReq)" call.

		}

	RBufReadStream stream(*iBuffer);

	for(TInt i=0; i<sentByServer; i++)

		{

		// Give the event to the observer

		CLogEvent* event = CLogEvent::NewL();

		CleanupStack::PushL(event);

		//

		stream >> *event;

		iObserver.HandleFetchedWindowItemL(i, event);

		CleanupStack::Pop(event);

		}

	// Do we need to fetch the next batch?

	iWindowReq.iLower += sentByServer; // the lower array index for next request

	if(iWindowReq.iLower <= iWindowReq.iUpper)

		{

		// Fetch some more

		Fetch(iWindowReq);

		}

	else

		{

		// All done?

		iBuffer->ResizeL(KLogWindowFetchBufferMinimumBufferSize);

		iRequestedWindow.iValid = ETrue;

		CompleteObserver(KErrNone);

		}

	}

void CLogViewWindowFetcher::DoCancel()

	{

	if	(iData().iOperationId > 0)

		{

		const TInt errorIgnored = iSession.Send(ELogOperationCancel, TIpcArgs(&iData));

		(void) errorIgnored;

		//

		iData().iOperationId = KLogNullOperationId;

		}

	CompleteObserver(KErrCancel);

	}

TInt CLogViewWindowFetcher::RunError(TInt aError)

	{

	CompleteObserver(aError);

	return KErrNone;

	}

/////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////

void CLogViewWindowFetcher::Fetch(const TLogWindow& aWindow)

	{

	iFetchWindowData().iLower = aWindow.iLower;

	iFetchWindowData().iUpper = aWindow.iUpper;

	//

	iData().iOperationId = iSession.AllocateIdOperation();

	//

	iSession.Send(ELogViewOperationInitiate, TIpcArgs(&iData,iViewId,&iFetchWindowData,&iBufferPointer), iStatus);

	SetActive();

	}

void CLogViewWindowFetcher::CompleteObserver(TInt aError)

	{

	if	(iObserverRequestStatus)

		User::RequestComplete(iObserverRequestStatus, aError);

	}