// Copyright (c) 2004-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 "CBackupRestoreNotification.h"


/** Default constructor. 
 *	@param aCallback reference to observer class object.
 */
CBackupRestoreNotification::CBackupRestoreNotification(MBackupRestoreNotificationObserver& aCallback)
:	
	CActive(CActive::EPriorityStandard), 
	iObserver(aCallback)
	{
	
	CActiveScheduler::Add(this);
	}


/** Destructor.
 */
EXPORT_C CBackupRestoreNotification::~CBackupRestoreNotification()
	{
	Cancel();
	iBackupNotification.Close();
	}

/** 
 *	A class wishing to be notified of a Backup/Restore shoud be derived from 
 *	MBackupRestoreNotificationObserver and pass a self reference.
 *	@param	aFilename	full filename of the file which needs monitoring.
 *	@param aCallback should usually be a pointer to the class calling this function.
 */
EXPORT_C CBackupRestoreNotification* CBackupRestoreNotification::NewL(const TDesC& aFilename, 
												MBackupRestoreNotificationObserver& aCallback)
	{
	CBackupRestoreNotification* self = new(ELeave) CBackupRestoreNotification(aCallback);
	CleanupStack::PushL(self);
	self->ConstructL(aFilename);
	CleanupStack::Pop(self);
	return self;
	}

/** 
 *	Indicates if a Backup operation is currently taking place.
 *	@return	ETrue if operation in progress else EFalse.
 */
EXPORT_C TBool CBackupRestoreNotification::BackupInProgress() const
	{
	return (iCurrentState & (conn::EBURBackupPartial | conn::EBURBackupFull));
	}

/** 
 *	Indicates if a Restore operation is currently taking place.
 *	@return	ETrue if operation in progress else EFalse.
 */
EXPORT_C TBool CBackupRestoreNotification::RestoreInProgress() const
	{
	return (iCurrentState & (conn::EBURRestorePartial | conn::EBURRestoreFull));
	}



/** 
 *	Initial registration with Publish&Subscribe for KUidBackupRestoreKey.
 *	@param full filename of the file being backed and which needs monitoring. 
 */
void CBackupRestoreNotification::ConstructL(const TDesC& /*aFilename*/)
	{
	// Initial subscribe to the Backup and Restore Flag.
	// The first ID indicates the type of flag being subscribed to.
	// The second ID is the actual Backup/Restore flag.
	iBackupNotification.Attach(KUidSystemCategory, conn::KUidBackupRestoreKey);
	iBackupNotification.Subscribe(iStatus);
	
	// Check to see if a Backup/Restore is currently underway.
	TInt newState=0;
	if (iBackupNotification.Get(newState)!=KErrNotFound)
		{
		ProcessInitialStateL(newState);
		}

	SetActive();
	}


/** 
 *	Have been notifed of a change in the backup/restore falg value.
 *	Re-register for changes to the backup flag. Then evaluate which observer 
 *	function need to be called.
 *	@see CActive
 */
void CBackupRestoreNotification::RunL()
	{
	// Resubscribe before dealing with the current notification.
	iBackupNotification.Subscribe(iStatus);
	SetActive();

	// Flag updated. What to do..
	TInt newState=0;
	if (iBackupNotification.Get(newState)!=KErrNotFound)
		{
		ReceivedNotificationL(newState);
		}
	}


TInt CBackupRestoreNotification::RunError(TInt /* aError */)
	{ // recover after handler for notification left
	return (KErrNone);
	}


/**
 * @see CActive
 */
void CBackupRestoreNotification::DoCancel()
	{
	iBackupNotification.Cancel();
	}


/**
 * Determines what operation is starting or has completed
 * and calls the relevant observer function.
 * @param aNewState	flags indicating what the new backup/restore state is:
 *	ENoBackup or EBackupBase or EBackupIncremetal. Only interesed in BaseBackup.
 *  EBUR (Unset, Normal, BackupFull, BackupPartial, RestoreFull, RestorePartial)
 *
 *	1. No backup/restore is taking place = EBURNormal | ENoBackup		
 *	2. Backup operation starting = (EBURBackupFull || EBURBackupPartial) && EBackupBase
 *  3. Restore operation starting = (EBURRestoreFull || EBURRestorePartial) && EBackupBase
 *								
 */
void CBackupRestoreNotification::ReceivedNotificationL(TInt aNewState)
	{
	// We are starting a a new operation...
	// Was there a previous Restore which failed to complete ?
	if (!(aNewState & (conn::EBURNormal | conn::EBURUnset)) && RestoreInProgress())
		{
		iCurrentState=aNewState;
		iObserver.RestoreCompletedL(KErrAbort);		
		}

	// A Backup or Restore taking place.
	if (aNewState & (conn::EBURBackupPartial | conn::EBURBackupFull) )
		{
		// Backup is taking place (either partial or full)
		iCurrentState=aNewState;
		iObserver.BackupBeginningL();
		}
	else if (aNewState & (conn::EBURRestorePartial | conn::EBURRestoreFull)) 
		{
		// Restore is taking place (either partial or full)
		iCurrentState=aNewState;
		iObserver.RestoreBeginningL();
		}
	else if (aNewState & (conn::EBURNormal | conn::EBURUnset))
		{		
		// The state has changed to no backup/restore
		// Decide which operation has just completed.
		if (BackupInProgress())
			{
			iCurrentState=aNewState;
			iObserver.BackupCompletedL();
			}
		else if (RestoreInProgress())
			{
			iCurrentState=aNewState;
			iObserver.RestoreCompletedL(KErrNone);
			}		
		}
	}

void CBackupRestoreNotification::ProcessInitialStateL(TInt aNewState)
	{
	// A Backup or Restore is taking place.
	if (aNewState & (conn::EBURBackupPartial | conn::EBURBackupFull) )
		{
		// Backup is taking place (either partial or full) 
		iObserver.BackupBeginningL();
		}
	else if (aNewState & (conn::EBURRestorePartial | conn::EBURRestoreFull)) 
		{
		// Restore is taking place (either partial or full)
		iObserver.RestoreBeginningL();
		}	
	iCurrentState=aNewState;
	}