// restore.cpp
// 
// Copyright (c) 2008 - 2010 Accenture. All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the "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:
// Accenture - Initial contribution
//

#include "restore.h"

_LIT(KRestoreOp,	"-r");

//
// CRestoreDriver
//
CRestoreDriver* CRestoreDriver::NewL(MBackupParent& aParent)
	{
	CRestoreDriver* self = new (ELeave) CRestoreDriver(aParent);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

CRestoreDriver::CRestoreDriver(MBackupParent& aParent):
CActive(CActive::EPriorityStandard), iParent(aParent)
	{
	CActiveScheduler::Add(this);
	}

CRestoreDriver::~CRestoreDriver()
	{
	Cancel();
	}

void CRestoreDriver::ConstructL()
	{
	}

void CRestoreDriver::SendInstructionL(MBackupObserver::TFileLockFlags aInstruction)
	{
	iInstruction = aInstruction;
	switch (iInstruction)
		{
		case MBackupObserver::EReleaseLockNoAccess:
			LaunchProcessL();
		break;

		case MBackupObserver::ETakeLock:
			TerminateProcessL();
		break;

		default:
			User::Leave(KErrNotSupported);
		break;		
		};
	}

//
// CRestoreDriver::ChildProcessExists
// checks whether the backup_child process
// is already running
//
TBool CRestoreDriver::ChildProcessExists()
	{
	_LIT(KWildCard, "*");
	TName woop(KBackupProcessName);
	woop.Append(KWildCard);
	TFindProcess check(woop);
	TFullName name;
	TInt result = check.Next(name);
	if (result == KErrNone)
		return ETrue;	
	return EFalse;
	}

//
// CRestoreDriver::LaunchProcessL
// spawns the backup_child process
// & waits to rendezvous
//
void CRestoreDriver::LaunchProcessL()
	{
	if (ChildProcessExists())
		User::Leave(KErrInUse);
	
	_LIT(KExeExt, ".exe");
	TName name(KBackupProcessName);
	name.Append(KExeExt);
	User::LeaveIfError(iChild.Create(name, KRestoreOp, EOwnerProcess));
	iChild.Resume();
	iChild.Rendezvous(iStatus);
	SetActive();
	}

//
// CRestoreDriver::TerminateProcessL
// open the backup_child process & signal it's semaphore
// that semaphore is the signal to shut itself down cleanly
//
void CRestoreDriver::TerminateProcessL()
	{
	if (!ChildProcessExists())
		User::Leave(KErrNotFound);
	
	// signal the semaphore 
	RSemaphore sem;
	User::LeaveIfError(sem.OpenGlobal(KBackupSemaphore, EOwnerProcess));
	sem.Signal();

	SelfComplete(KErrNone);
	}

void CRestoreDriver::SelfComplete(const TInt aError)
	{
	ASSERT(!IsActive());
	iStatus = KRequestPending;
	TRequestStatus* status = &iStatus;
	User::RequestComplete(status, aError);
	SetActive();
	}

//
// CRestoreDriver::RunL
// 
void CRestoreDriver::RunL()
	{
	iParent.Finished(iStatus.Int());
	}

//
// CRestoreDriver::DoCancel
//
void CRestoreDriver::DoCancel()
	{
	ASSERT(EFalse); // not dealing with this!
	}


//
// CCmdRestore
//
CCommandBase* CCmdRestore::NewLC()
	{
	CCmdRestore* self = new (ELeave) CCmdRestore();
	CleanupStack::PushL(self);
	self->BaseConstructL();
	return self;
	}

CCmdRestore::~CCmdRestore()
	{
	delete iRestore;
	}

CCmdRestore::CCmdRestore() : 
CCommandBase(CCommandBase::EManualComplete)
	{
	}

const TDesC& CCmdRestore::Name() const
	{
	_LIT(KName, "restore");	
	return KName;
	}

void CCmdRestore::DoRunL()
	{
	// spawn the stuff I need to do the task
	iRestore = CRestoreDriver::NewL(*this);

	// process the argument
	MBackupObserver::TFileLockFlags flag = MBackupObserver::EReleaseLockNoAccess;

	switch (iOperation)
		{
	case EStart:
		flag = MBackupObserver::EReleaseLockNoAccess;
		break;
	case EStop:
		flag = MBackupObserver::ETakeLock;
		break;
	default:
		User::LeaveIfError(KErrArgument);
		}
			
	// send the instruction through
	iRestore->SendInstructionL(flag);
	}

void CCmdRestore::ArgumentsL(RCommandArgumentList& aArguments)
	{
	_LIT(KArgOperation, "operation");
	aArguments.AppendEnumL((TInt&)iOperation, KArgOperation);
	}

void CCmdRestore::OptionsL(RCommandOptionList&)
	{
	}

void CCmdRestore::Finished(const TInt aError)
	{
	Complete(aError);
	}

EXE_BOILER_PLATE(CCmdRestore)