// 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);
	}