// 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 "LogServViewChangeManager.h"

 #include <s32mem.h>

 #include "logservpanic.h"

 #include "LogServDatabaseChangeInterface.h"

 // Constants

 const TInt KLogServViewChangeDefinitionGranularity = 10;

 const TInt KLogServViewChangeQueueGranularity = 3;

 const TInt KLogServViewChangeBufferGranularity = 40;

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

 // -----> CLogServViewChangeManager (source)

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

 CLogServViewChangeManager::CLogServViewChangeManager(MLogServDatabaseChangeInterface& aChangeInterface)

 :	iChangeInterface(aChangeInterface), iPendingChanges(KLogServViewChangeQueueGranularity)

 	{

 	}

 CLogServViewChangeManager::~CLogServViewChangeManager()

 	{

 	delete iTransientChangeDefinition;

 	//

 	iPendingChanges.ResetAndDestroy();

 	iPendingChanges.Close();

 	}

 void CLogServViewChangeManager::ConstructL()

 	{

 	iTransientChangeDefinition = CLogChangeDefinition::NewL(KLogServViewChangeDefinitionGranularity);

 	}

 CLogServViewChangeManager* CLogServViewChangeManager::NewL(MLogServDatabaseChangeInterface& aChangeInterface)

 	{

 	CLogServViewChangeManager* self = new(ELeave) CLogServViewChangeManager(aChangeInterface);

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop(self);

 	return self;

 	}

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

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

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

 void CLogServViewChangeManager::ChangeTransactionPrepare()

 	{

 	iTransientChangeDefinition->Reset();

 	}

 void CLogServViewChangeManager::ChangeTransactionSubmitL(TLogId aId, TLogDatabaseChangeType aType, TInt aViewIndex)

 	{

 	iTransientChangeDefinition->AddL(aId, aType, aViewIndex);

 	}

 void CLogServViewChangeManager::ChangeTransactionCommitL()

 	{

 	// We can only tell the client-side view change observer about the changes if:

 	//

 	// (2) we actually have something to tell the client views (some changes)

 	// (3) we have an outstanding client-side change message pointer

 	//

 	const TInt count = iTransientChangeDefinition->Count();

 	if	(count > 0) // (2)

 		{

 		// Do we have any existing pending changes? We can't alter the contents of the

 		// first pending change, since the client may already be preparing a client-side

 		// buffer of the requisite size. We can, however, combine the 2nd batch of changes

 		// with this new set so there is less IPC required (although more memory).

 		const TInt pendingChangeCount = iPendingChanges.Count();

 		if	(pendingChangeCount >= 2)

 			{

 			CLogChangeDefinition* changeDef = CLogChangeDefinition::NewL();

 			CleanupStack::PushL(changeDef);

 			//

 			CBufBase* buffer = iPendingChanges[1];

 			RBufReadStream readStream(*buffer);

 			//

 			readStream >> *changeDef;

 			// Add new changes

 			TLogId logId = KLogNullId;

 			TLogDatabaseChangeType type = ELogChangeTypeUndefined;

 			TInt viewIndex = 0;

 			//

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

 				{

 				type = iTransientChangeDefinition->At(i, logId, viewIndex);

 				changeDef->AddL(logId, type, viewIndex);

 				}

 			// Write the whole lot out again

 			buffer->Delete(0, buffer->Size());

 			RBufWriteStream writeStream(*buffer);

 			writeStream << *changeDef;

 			buffer->Compress();

 			CleanupStack::PopAndDestroy(changeDef);

 			}

 		else

 			{

 			CBufBase* buffer = CBufFlat::NewL(KLogServViewChangeBufferGranularity);

 			CleanupStack::PushL(buffer);

 			// Externalize changes

 			RBufWriteStream stream(*buffer);

 			stream << *iTransientChangeDefinition; 

 			buffer->Compress();

 			// Add to container

 			User::LeaveIfError(iPendingChanges.Append(buffer));

 			CleanupStack::Pop(buffer);

 			}

 		// Notify if necessary - handles (3) implicitly

 		NotifyClient();

 		}

 	// Free some memory

 	iTransientChangeDefinition->Reset();

 	}

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

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

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

 void CLogServViewChangeManager::DeliverChangesL(const RMessage2& aMessage)

 	{

 	if	(iPendingChanges.Count())

 		{

 		CBufBase* headItem = iPendingChanges[0];

 		//

 		const TInt expectedChangesSize = aMessage.Int1();

 		const TPtr8 pBufferContents(headItem->Ptr(0));

 		// Check buffer size is as we expect

 		if	(expectedChangesSize != pBufferContents.Size())

 			::PanicClientL(aMessage, ELogViewBadClientSideChangeBufferSize);

 		else

 			{

 			// Write back to client-side

 			aMessage.WriteL(2, pBufferContents);

 			// Remove the item

 			iPendingChanges.Remove(0);

 			delete headItem;

 			}

 		}

 	else

 		::PanicClientL(aMessage, ELogViewNoPendingChangesToDeliver);

 	}

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

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

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

 void CLogServViewChangeManager::RequestChangeNotifications(const RMessage2& aMessage)

 	{

     if	(iClientSideChangeMessage == RMessagePtr2())

 		{

 		// Notify if we have any cached changes...

 		iClientSideChangeMessage = aMessage;

 		NotifyClient();

 		}

 	else

 		PanicClient(aMessage, ELogViewChangeRequestAlreadyIssued);

 	}

 void CLogServViewChangeManager::RequestChangeNotificationsCancel()

 	{

     if	(iClientSideChangeMessage != RMessagePtr2())

 		CompleteClientChangeMessage(KErrCancel);

 	// Zap all the pending changes too

 	iPendingChanges.ResetAndDestroy();

 	iPendingChanges.GranularCompress();

 	}

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

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

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

 void CLogServViewChangeManager::NotifyClient()

 	{

 	const TInt count = iPendingChanges.Count();

     if	(iClientSideChangeMessage != RMessagePtr2() && count)

 		{

 		CBufBase* headItem = iPendingChanges[0];

 		const TInt messageSize = headItem->Size();

 		CompleteClientChangeMessage(messageSize);

 		}

 	}

 void CLogServViewChangeManager::CompleteClientChangeMessage(TInt aCompletionCode)

 	{

 	__ASSERT_ALWAYS(iClientSideChangeMessage != RMessagePtr2(), Panic(ELogViewNoClientChangeMessageOutstanding));

 	iClientSideChangeMessage.Complete(aCompletionCode);

 	}