// 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 "LogNotify.h"
#include "logservpanic.h"
#include "LogServBackupInterface.h"
#include "LogServDatabaseChangeInterface.h"


CLogNotify::CLogNotify(MLogServBackupInterface& aBackupInterface, MLogServDatabaseChangeInterface& aChangeInterface, TInt aPriority)
:	CTimer(aPriority), iBackupInterface(aBackupInterface), iChangeInterface(aChangeInterface), iCompleteClientMessage(ETrue)
	{
	CActiveScheduler::Add(this);
	}

CLogNotify::~CLogNotify()
	{
	LOGTEXT("CLogNotify::~CLogNotify()");

	// This will only complete the client-side request if its not already
	// been completed
	Cancel();
	//
	iChangeInterface.DCIRequestChangeNotificationsCancel(*this);
	iBackupInterface.BIObserverRemove(*this);

	LOGTEXT("CLogNotify::~CLogNotify() - end");
	}

void CLogNotify::ConstructL()
	{
	LOGTEXT("CLogNotify::ConstructL()");

	CTimer::ConstructL();

	// Register for change events
	iChangeInterface.DCIRequestChangeNotificationsL(*this);

	// Register for backup events
	iBackupInterface.BIObserverAddL(*this, MLogServBackupInterface::EObjectClientChangeNotifications);

	LOGTEXT("CLogNotify::ConstructL() - end");
	}

CLogNotify* CLogNotify::NewL(MLogServBackupInterface& aBackupInterface, MLogServDatabaseChangeInterface& aChangeInterface, TInt aPriority)
	{
	CLogNotify* self = new(ELeave)CLogNotify(aBackupInterface, aChangeInterface, aPriority);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(); // self
	return self;
	}

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

void CLogNotify::DCOHandleChangeEventsL(const CLogChangeDefinition& /*aChanges*/)
//
//	Handle changes within the log database
//
	{
	LOGTEXT2("CLogNotify::DCOHandleChangeEventsL() - client thread is: %S", &iClientThreadName);

	// Increment number of changes but only notify the client side request
	// if the delay timer isn't running.
	++iCommit;
	//
	if	(!IsActive())
		CheckForChanges();

	LOGTEXT("CLogNotify::DCOHandleChangeEventsL() - end");
	}

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

void CLogNotify::BOHandleEventL(TLogServBackupEvent aEvent)
	{
	switch(aEvent)
		{
	case EBackupStarting:
		LOGTEXT("CLogNotify::BOHandleEventL(EBackupStarting)");

		// A rather inelegant fix but gets rid of one whole class
		iCompleteClientMessage = EFalse;
		Cancel();
		iCompleteClientMessage = ETrue;
		break;

	case EBackupEnded:
		LOGTEXT("CLogNotify::BOHandleEventL(EBackupEnded)");
		// Simulate a change
		++iCommit;
		if	(!IsActive())
			CheckForChanges();
		break;
		}

	LOGTEXT("CLogNotify::BOHandleEventL() - end");
	}

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

void CLogNotify::Notify(TTimeIntervalMicroSeconds32 aDelay, const RMessage2& aMessage)

	{
#ifdef LOGGING_ENABLED
	RThread t;
	aMessage.Client(t);
	iClientThreadName = t.Name();
	t.Close();
	LOGTEXT3("CLogNotify::Notify(%d, %S)", aDelay.Int(), &iClientThreadName);
#endif

	__ASSERT_DEBUG(!IsActive(), Panic(ELogAlreadyActive18));
	Cancel();

	// Reset our change counter
	if (iLastCommit == 0)
		iLastCommit = iCommit;

	// Save a message pointer to client request status
	iMessagePtr = aMessage;

	// Wait until the delay has passed before notifying clients of changes
	After(aDelay);

	LOGTEXT("CLogNotify::Notify() - end");
	}

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

void CLogNotify::Cancel()
	{
	LOGTEXT2("CLogNotify::Cancel() - client thread is: %S", &iClientThreadName);

	CActive::Cancel();

	// Reset
	iLastCommit = 0;

	// Complete the client-side observer
	if	(iCompleteClientMessage)
		CompleteClientRequest(KErrCancel);

	LOGTEXT("CLogNotify::Cancel() - end");
	}

void CLogNotify::RunL()
//
//	RunL is called if the timer has expired
//
	{
	LOGTEXT3("CLogNotify::RunL(%d) - client thread is: %S", iStatus.Int(), &iClientThreadName);

	CheckForChanges();

	LOGTEXT("CLogNotify::RunL() - end");
	}

void CLogNotify::DoCancel()
	{
	LOGTEXT2("CLogNotify::DoCancel() - client thread is: %S", &iClientThreadName);

	// This is what really cancel's us
	CTimer::DoCancel();

	LOGTEXT("CLogNotify::DoCancel() - end");
	}

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

void CLogNotify::CheckForChanges()
	{
	LOGTEXT4("CLogNotify::CheckForChanges() - iLastCommit = %d, iCommit = %d, client thread name: %S", iLastCommit, iCommit, &iClientThreadName);

	if	(iLastCommit != iCommit)
		{
		LOGTEXT("CLogNotify::CheckForChanges() - changes detected, attempting to notify client");
		iLastCommit = iCommit;
		CompleteClientRequest(RDbNotifier::ECommit);
		}

	LOGTEXT("CLogNotify::CheckForChanges() - end");
	}

void CLogNotify::CompleteClientRequest(TInt aCompletionCode)
	{
	LOGTEXT3("CLogNotify::CompleteClientRequest() - aCompletionCode = %d, thread: %S", aCompletionCode, &iClientThreadName);

	if	(!iMessagePtr.IsNull())
		{
		LOGTEXT2("CLogNotify::CompleteClientRequest() - completing outstanding client request status for thread: %S", &iClientThreadName);
		iMessagePtr.Complete(aCompletionCode);
		}
	else
		{
		LOGTEXT2("CLogNotify::CompleteClientRequest() - thread %S doesn't have an outstanding notification request", &iClientThreadName);
		}

	LOGTEXT("CLogNotify::CompleteClientRequest() - end");
	}