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

 // User includes

 #include <logcli.h>

 #include "logservpanic.h"

 // Constants

 const TInt KTimerDelay = 10000000; // 10 seconds

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

 // -----> CLogServBackupManager (source)

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

 CLogServBackupManager::CLogServBackupManager(TInt aPriority)

 :	CTimer(aPriority)

 	{

 	CActiveScheduler::Add(this);

 	}

 CLogServBackupManager::~CLogServBackupManager()

 	{

 	__ASSERT_DEBUG(iObservers.Count() == 0, Panic(ELogBackupObserversStillRegistered));

 	Cancel();

 	// Unregister ourselves with backup server

 	if (iBackup)

 		{

 		if	(iDatabaseName)

 			iBackup->DeregisterFile(*iDatabaseName);

 		delete iBackup;

 		}

 	delete iDatabaseName;

 	iObservers.Close();

 	}

 void CLogServBackupManager::ConstructL()

 	{

 	CTimer::ConstructL();

 	}

 CLogServBackupManager* CLogServBackupManager::NewL(TInt aPriority)

 	{

 	CLogServBackupManager* self = new(ELeave) CLogServBackupManager(aPriority);

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop(self);

 	return self;

 	}

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

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

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

 void CLogServBackupManager::BIObserverAddL(MLogServBackupObserver& aObserver, TLogServBackupPriority aPriority)

 	{

 	LOGTEXT2("CLogServBackupManager::BIObserverAddL(aPriority=%d)", aPriority);

 	TLogBackupNotificationEntry entry(aObserver, aPriority);

 	// Create orderer which ensures that we place the objects in priority ascending order (i.e. 

 	// higher priority gets notified first).

 	TLinearOrder<TLogBackupNotificationEntry> orderer(CompareEntries);

 	const TInt error = iObservers.InsertInOrderAllowRepeats(entry, orderer);

 	User::LeaveIfError(error);

 	LOGTEXT("CLogServBackupManager::BIObserverAddL() - end");

 	}

 void CLogServBackupManager::BIObserverRemove(MLogServBackupObserver& aObserver)

 //

 //	Removes an observer from the notification queue

 //

 	{

 	const TInt count = iObservers.Count();

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

 		{

 		const TLogBackupNotificationEntry& entry = iObservers[i];

 		if	(&aObserver == &entry.iObserver)

 			{

 			iObservers.Remove(i);

 			return;

 			}

 		}

 	}

 MLogServBackupInterface::TLogServBackupState CLogServBackupManager::BIState() const

 	{

 	return iState;

 	}

 TInt CLogServBackupManager::BIErrorValueForCurrentState() const

 	{

 	TInt error = KErrNone;

 	switch(BIState())

 		{

 	case ELogServBackupStateIdle:

 		error = KErrNone;

 		break;

 	case ELogServBackupStateBackupInProgress:

 		error = KErrAccessDenied;

 		break;

 		}

 	//

 	LOGTEXT2("CLogServBackupManager::BIErrorValueForCurrentState() = %d", error);

 	return error;

 	}

 void CLogServBackupManager::BISetDatabaseNameL(const TDesC& aDatabaseName)

 	{

 #ifdef LOGGING_ENABLED

 	LOGTEXT3("CLogServBackupManager::BISetDatabaseNameL(%S, isActive: %d)", &aDatabaseName, IsActive());

 	if	(iDatabaseName)

 		{

 		LOGTEXT2("CLogServBackupManager::BISetDatabaseNameL() - currently registered database filename is: %S", iDatabaseName);

 		}

 	else

 		{

 		LOGTEXT("CLogServBackupManager::BISetDatabaseNameL() - no file registered with backup interface yet");

 		}

 #endif

 	Cancel();

 	HBufC* databaseName = aDatabaseName.AllocLC();

 	// If we haven't already created a backup observer, then we need

 	// to kick the object back into life again.

 	if	(!iBackup)

 		{

 		LOGTEXT("CLogServBackupManager::BISetDatabaseNameL() - no backup session created");

 		// Try and create backup interface synchronously first of all, if that fails

 		// then construct as an idle operation

 		TRAPD(err, iBackup = CreateBackupL(*databaseName));

 		LOGTEXT2("CLogServBackupManager::BISetDatabaseNameL() - backup session creation error: %d", err);

 		if	(err != KErrNone)

 			After(0);

 		}

 	else if (iDatabaseName->Compare(aDatabaseName) != KErrNone)

 		{

 		LOGTEXT3("CLogServBackupManager::BISetDatabaseNameL() - database filename changed from %S to %S", &iDatabaseName, &aDatabaseName);

 		// De register the old, register the new

 		iBackup->DeregisterFile(*iDatabaseName);

 		iBackup->RegisterFileL(aDatabaseName, *this);

 		LOGTEXT("CLogServBackupManager::BISetDatabaseNameL() - database re-registration complete");

 		}

 	delete iDatabaseName;

 	iDatabaseName = databaseName;

 	CleanupStack::Pop(databaseName);

 	LOGTEXT("CLogServBackupManager::BISetDatabaseNameL() - end");

 	}

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

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

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

 void CLogServBackupManager::RunL()

 //

 // This method does two things

 //

 // 1) Keeps trying to create a backup object - which may fail on device 

 //    bootup until the ui framework starts the backup server.

 //

 // 2) Handles the case where the server fails to restart correctly after a backup - it keeps trying

 //

 	{

 	LOGTEXT2("CLogServBackupManager::RunL(%d)", iStatus.Int());

 	if	(!iBackup)

 		{

 		LOGTEXT("CLogServBackupManager::RunL() - trying to create backup object");

 		// Keep trying to create backup object

 		iBackup = CreateBackupL(*iDatabaseName);

 		LOGTEXT("CLogServBackupManager::RunL() - backup object created okay");

 		}

 	else

 		{

 		// This branch is executed if we failed to create the backup object on our first

 		// attempt in BISetDatabaseNameL

 		LOGTEXT("CLogServBackupManager::RunL() - notifying observers about dummy backup ended event");

 		NotifyObservers(MLogServBackupObserver::EBackupEnded);

 		}

 	LOGTEXT("CLogServBackupManager::RunL() - end");

 	}

 TInt CLogServBackupManager::RunError(TInt aError)

 	{

 	(void) aError;

 	LOGTEXT2("CLogServBackupManager::RunError(%d)", aError);

 	// Make sure we don't leak anything, pretend the backup started again - won't fail

 	if	(iBackup)

 		NotifyObservers(MLogServBackupObserver::EBackupStarting);

 	After(KTimerDelay);

 	LOGTEXT("CLogServBackupManager::RunError() - end");

 	return KErrNone;

 	}

 TInt CLogServBackupManager::NotifyObservers(MLogServBackupObserver::TLogServBackupEvent aEvent)

 //

 //	Notify observers of the event. Assumes event queue correctly ordered.

 //

 	{

 	const TInt count = iObservers.Count();

 	LOGTEXT3("CLogServBackupManager::NotifyObservers(aEvent = %d) - %d observers", aEvent, count);

 	// Depending on the event type, we have to reverse the order of notification.

 	// I wish it was possible to do this in a more elegant way... hmm... pointers

 	// to member functions?...

 	TInt error = KErrNone;

 	TRAP(error, 

 		//

 		switch(aEvent)

 			{

 		case MLogServBackupObserver::EBackupStarting:

 			{

 			// Update our state

 			iState = ELogServBackupStateBackupInProgress;

 			// Notify

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

 				{

 				TLogBackupNotificationEntry& entry = iObservers[i];

 				entry.iObserver.BOHandleEventL(aEvent);

 				}

 			}

 			break;

 		case MLogServBackupObserver::EBackupEnded:

 			{

 			// Update our state

 			iState = ELogServBackupStateIdle;

 			// Notify

 			for(TInt i=count-1; i>=0; i--)

 				{

 				TLogBackupNotificationEntry& entry = iObservers[i];

 				entry.iObserver.BOHandleEventL(aEvent);

 				}

 			}

 			break;

 			}

 		);

 	LOGTEXT("CLogServBackupManager::NotifyObservers() - end");

 	return error;

 	}

 void CLogServBackupManager::ChangeFileLockL(const TDesC& aFileName, TFileLockFlags aFlags)

 	{

 	LOGTEXT3("CLogServBackupManager::ChangeFileLockL(%S, aFlags = %d)", &aFileName, aFlags);

 #ifdef LOGGING_ENABLED

 	if	(aFlags & (MBackupObserver::EReleaseLockReadOnly | MBackupObserver::EReleaseLockNoAccess))

 		{

 		LOGTEXT("CLogServBackupManager::ChangeFileLockL() - Backup is STARTING");

 		}

 	else

 		{

 		LOGTEXT("CLogServBackupManager::ChangeFileLockL() - Backup is ENDING");

 		}

 #endif

 	Cancel();

 	// This probably won't ever happen

 	if	(iDatabaseName->Compare(aFileName) != 0)

 		{

 		LOGTEXT("CLogServBackupManager::ChangeFileLockL() - Notification from backup server about the wrong file!");

 		User::Leave(KErrNotFound);

 		}

 	// Work out type of backup event

 	MLogServBackupObserver::TLogServBackupEvent event = MLogServBackupObserver::EBackupEnded;

 	if	(aFlags & (MBackupObserver::EReleaseLockReadOnly | MBackupObserver::EReleaseLockNoAccess))

 		event = MLogServBackupObserver::EBackupStarting;

 	// Notify observers

 	const TInt error = NotifyObservers(event);

 	LOGTEXT2("CLogServBackupManager::ChangeFileLockL() - notifying observers error: %d", error);

 	// Shouldn't be any problems when notifying observers

 	__ASSERT_DEBUG(!(event == MLogServBackupObserver::EBackupStarting && error != KErrNone), Panic(ELogStartBackupFailure));

 	// Handle failure to restart the server after a backup

 	if	(error && (event == MLogServBackupObserver::EBackupEnded))

 		{

 		LOGTEXT("CLogServBackupManager::ChangeFileLockL() - Kicking off server objects again after backup completed (and there was an error)");

 		// Make sure we don't leak anything, pretend the backup started again - won't fail

 		Cancel();

 		NotifyObservers(MLogServBackupObserver::EBackupStarting);

 		After(KTimerDelay);

 		}

 	LOGTEXT("CLogServBackupManager::ChangeFileLockL() - end");

 	}

 CBaBackupSessionWrapper* CLogServBackupManager::CreateBackupL(const TDesC& aLogDatabaseFileName)

 	{

 	LOGTEXT("CLogServBackupManager::CreateBackupL()");

 	// Create backup session

 	CBaBackupSessionWrapper* backup = CBaBackupSessionWrapper::NewL();

 	CleanupStack::PushL(backup);

 	// Register with the backup server

 	backup->RegisterFileL(aLogDatabaseFileName, *this);

 	// All done

 	CleanupStack::Pop(backup);

 	LOGTEXT("CLogServBackupManager::CreateBackupL() - end");

 	return backup;

 	}

 TInt CLogServBackupManager::CompareEntries(const TLogBackupNotificationEntry& aLeft, const TLogBackupNotificationEntry& aRight)

 	{

 	if	(aLeft.iPriority == aRight.iPriority)

 		return 0;

 	else if (aLeft.iPriority > aRight.iPriority) // Not what you might expect since higher priority must go first

 		return -1;

 	return 1;

 	}