// Copyright (c) 2001-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:

//

//#define __BACKUP_LOGGING

#ifdef __BACKUP_LOGGING

	#define _BACKUPLOG( a ) RFileLogger::WriteFormat(_L("msgs"),_L("backup.txt"),EFileLoggingModeAppend, a );	

	#define _BACKUPLOGERR( a, b ) RFileLogger::WriteFormat(_L("msgs"),_L("backup.txt"),EFileLoggingModeAppend, a , b);	

#else

	#define _BACKUPLOG( a )

	#define _BACKUPLOGERR( a, b )

#endif

#include "CMsvBackupHandler.h"

#include "MSVSERV.H"

#include "MSVSTD.H"

#include "msvdbadapter.h"

#include "msvindexadapter.h"

#include <msvapi.h>

#include <e32base.h>

#include <e32property.h>

#include <connect/sbdefs.h>

#if (defined SYMBIAN_MESSAGESTORE_UNIT_TESTCODE)

_LIT(KDBFileNamePath,"\\messaging.db");

#else

_LIT(KDBFileNamePath,"\\private\\10281e17\\[1000484B]messaging.db");

#endif

CMsvBackupHandler* CMsvBackupHandler::NewL(CMsvServer& aServer)

	{

	CMsvBackupHandler* self=new (ELeave) CMsvBackupHandler(aServer);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return(self);

	}

CMsvBackupHandler::CMsvBackupHandler(CMsvServer& aServer) : iServer(aServer)

	{

	}

CMsvBackupHandler::~CMsvBackupHandler()

	{

	_BACKUPLOG(_L("backup handler ending\r\n"));

	// Unregister ourselves with backup server

	if (iBackup)

		{

		iBackup->DeregisterFile(iFileName);

		delete iBackup;

		}

	}

void CMsvBackupHandler::ConstructL()

	{

	_BACKUPLOG(_L("Backup handler started\r\n"))

	TParse parse;

	RFs fs;

	CleanupClosePushL(fs);

	User::LeaveIfError(fs.Connect());

	TPtrC driveName = TDriveUnit(MessageServer::CurrentDriveL(fs)).Name();

	iFileName = KDBFileNamePath;

	parse.Set(iFileName, &driveName, NULL);

	CleanupStack::PopAndDestroy();		// fs

	iFileName=parse.FullName();

	iState=EHaveLock;

	// Create backup session

	iBackup = CBaBackupSessionWrapper::NewL();

	// Register with the backup server

	iBackup->RegisterFileL(iFileName, *this);

	// All done

	_BACKUPLOGERR(_L("File Registered with Backup Server: \"%S\"\r\n"), &iFileName);

	}

TBool CMsvBackupHandler::Locked()

	{

	if(iState==EHaveLock) 

		{

		return(EFalse);

		}

	else 

		{

		return(ETrue);

		}

	}

#ifdef __BACKUP_LOGGING

void CMsvBackupHandler::ChangeFileLockL(const TDesC& aFileAffected, TFileLockFlags aFlags)

#else

void CMsvBackupHandler::ChangeFileLockL(const TDesC& /*aFileAffected*/, TFileLockFlags aFlags)

#endif

	{

	_BACKUPLOG(_L("Got backup event\r\n"))

	_BACKUPLOGERR(_L("File affected: \"%S\"\r\n"), &aFileAffected);

	switch(aFlags)

		{

		case ETakeLock: // this state gives me the lock back after it has been taken away from me.

			{

			_BACKUPLOG(_L("Take lock\r\n"))

			if(iState==EReleasedForBackup)

				{

				iState=EHaveLock;

				_BACKUPLOG(_L("from backup\r\n"))

				//Change error state to none

				iServer.Context().IndexAdapter()->SetErrorState(KErrNone);

				//Change State

				iServer.SetStartupState(EMsvNullNotification);

				_BACKUPLOG(_L("Reloading context\r\n"))

				ReloadContextL();

				}

			else if(iState==EReleasedForRestore)

				{

				// Reload context will result in this object being deleted

				// therefore this is no longer valid;

				iState=EHaveLock;							

				//reload as its a new db after restore

				ReloadContextL();

				}

			else

				{

				_BACKUPLOG(_L("bad state\r\n"))

				__ASSERT_DEBUG(EFalse,PanicServer(EMsvBackupHandlerInUnkownState));

				}

			break;

			}

		case EReleaseLockNoAccess:

			{

			// please release the lock and don't read or write to the file

			_BACKUPLOG(_L("release no access\r\n"))

			// Need to find whether this file lock release request is due to a restore happening.  

			// It is possible that the file system may need us to release our locks for some other 

			// purpose such as formatting an MMC card.

			TInt backupRestoreState = 0;

			RProperty property;

			TInt err = property.Get(KUidSystemCategory, conn::KUidBackupRestoreKey, backupRestoreState);

			property.Close();

			User::LeaveIfError(err);

			_BACKUPLOGERR(_L("backupRestoreStateValue: \"0x%08x\"\r\n"), backupRestoreState);

			if ((backupRestoreState & conn::EBURRestoreFull) || (backupRestoreState & conn::EBURRestorePartial))

				{

				// This means they will be restoring the file so I will

				// have to cope with a new index when I get the lock back.

				if(DetachFromFile(KMsvIndexRestore)!=EFalse)

					{

					_BACKUPLOG(_L("A genuine restore is happening\r\n"))

					iState=EReleasedForRestore;

					}

				}

			else

				{

				// Not a restore operation, so no need to reload the index when 

				// I get the lock back.

				// Use KMsvIndexRestore to tell the index not to write anything to disk 

				// while the file system is locked...

				if(DetachFromFile(KMsvIndexRestore)!=EFalse) 

					{

					// ...but use EReleasedForBackup here so that we don't reload the index from disk

					// when we get the ETakeLock notification - this would overwrite any index

					// changes that have happened while the file system was locked, which we want to 

					// keep if the file system was locked for any reason other than Restore.

					_BACKUPLOG(_L("File system detached for read and write, but not for a restore\r\n"))

					iState=EReleasedForBackup;

					}

				}

			_BACKUPLOG(_L("released for no access\r\n"))

			break;

			}

		case EReleaseLockReadOnly:

			{

			// please release the lock and don't write to the file, I won't read

			// or write but I also assume the file is being backed up and therefore

			// the same index will be there when I have finished.

			_BACKUPLOG(_L("release no read only\r\n"))

			if(DetachFromFile(KMsvIndexBackup)!=EFalse)

				{

				iState=EReleasedForBackup;

				}

			_BACKUPLOG(_L("released for read only\r\n"))

			break;

			}

		default:

			{

			_BACKUPLOG(_L("bad event\r\n"))

			__ASSERT_DEBUG(EFalse,PanicServer(EMsvBackupObserverGotUnknownEvent));

			break;

			}

		}

	};

TBool CMsvBackupHandler::DetachFromFile(TInt aErrorState)

	{

	// if the context is currently in an error state don't do anything,

	// the current implications of this are that when the disk is removed

	// or the wrong disk is in the drive and we are asked to release a lock

	// on the file we won't.

	_BACKUPLOG(_L("detach to file\r\n"))

	TInt error = KErrNone;

	error = iServer.Context().IndexAdapter()->ErrorState();

	if(error == KErrNone)

		{

		_BACKUPLOG(_L("context good for closing\r\n"))

		_BACKUPLOG(_L("closing\r\n"))

#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

		TUint currDriveIndex = CMsvPreferredDriveList::GetDriveList()->CurrentDriveIndex();

		TDriveNumber currDriveNum = CMsvPreferredDriveList::GetDriveList()->CurrentDriveNumber();

		// Flush Cache. This will also detach the DB.

		TRAP(error, iServer.Context().IndexAdapter()->RemoveDriveL(KCurrentDriveId, currDriveIndex, EFalse));

		if(error)

			return(EFalse);

		// current drive is detached from DB, so cannot access any entries from Database, so will

		// assing iDbAdpter pointer to temporary iTempDbAdapter pointer and assin NULL to iDbAdpter.

		iServer.Context().IndexAdapter()->BackupDbAdpter();

		TRAP(error, CMsvPreferredDriveList::GetDriveList()->UpdateDriveIdL(currDriveIndex, KCurrentDriveId));

		if(error)

			return(EFalse);

#else

		iEntry.iSize = 	iServer.Context().IndexAdapter()->GetDbAdapter()->Size();

		iServer.Context().IndexAdapter()->DeleteDbAdapter();

#endif		// #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

		_BACKUPLOG(_L("closed\r\n"))

		iServer.Context().IndexAdapter()->SetErrorState(aErrorState);	

		iServer.SetStartupState(EMsvMediaUnavailable);

		return(ETrue);

		}

	else

		{

		return(EFalse);

		}

	}

// CreateIndexL will result in this object being deleted

// so this is no longer valid

void CMsvBackupHandler::ReloadContextL()

	{

#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

	// for attaching current drive to main Database, assign iDbAdpter with iTempDbAdapter.

	iServer.Context().IndexAdapter()->RestoreDbAdpter();

	iServer.Context().IndexAdapter()->ReloadCacheL();

#else

	iServer.CreateIndexL(ETrue);

#endif

	}