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

_LIT(KBackupOp,		"-b");

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

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

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

void CBackupDriver::ConstructL()
	{
	}

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

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

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

//
// CBackupDriver::ChildProcessExists
// checks whether the backup_child process
// is already running
//
TBool CBackupDriver::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;
	}

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

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

	SelfComplete(KErrNone);
	}

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

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

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


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

CCmdBackup::~CCmdBackup()
	{
	delete iBackup;
	}

CCmdBackup::CCmdBackup() : 
CCommandBase(CCommandBase::EManualComplete)
	{
	}

const TDesC& CCmdBackup::Name() const
	{
	_LIT(KName, "backup");	
	return KName;
	}

void CCmdBackup::DoRunL()
	{
	// spawn the stuff I need to do the task
	iBackup = CBackupDriver::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
	iBackup->SendInstructionL(flag);
	}

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

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

EXE_BOILER_PLATE(CCmdBackup)