/*
* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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: 
*
*/


/**
 @file
*/

#include "watcherstep.h"

#include "drivewatcher.h"

#include "testutilclientswi.h"

namespace Swi
{

namespace Test
{

/**
 * This fakes a media change sicne we are using ENotifyEntry by creating
 * a dir under the private path we're receiving notifications.
 * This could possibly be improved to generate real notifications.
 */
void GenerateMediaChangeL(const TDesC& aPath)
	{
	
	RTestUtilSessionSwi fs;

	User::LeaveIfError(fs.Connect());
	CleanupClosePushL(fs);
	
	HBufC* path=HBufC::NewLC(aPath.Length()+128);
	TPtr pathPtr(path->Des());
	pathPtr.Format(_L("%Smedia_change_trigger"), &aPath);
	
	TInt err=fs.MkDirAll(pathPtr);
	if (err==KErrAlreadyExists)
		{
		err=fs.RmDir(pathPtr);
		}
	User::LeaveIfError(err);
	
	CleanupStack::PopAndDestroy(path);
	CleanupStack::PopAndDestroy(&fs);
	}
	
const TInt KDriveE='e'-'a'; // Drive E is our removable drive


CWatcherStep::CWatcherStep()
	{
	iError=KErrNone;
	}

CWatcherStep::~CWatcherStep()
	{
	}

void CWatcherStep::FreeMemory()
	{
	iNotifications.Reset();
	}

TVerdict CWatcherStep::runTestStepL(TBool /*aOomTest*/)
	{
	iActiveStep=CWatcherActiveStep::NewL(*this);
	iActiveStep->StartTest();
	delete iActiveStep;

	User::LeaveIfError(iError);
	return EPass;
	}


void CWatcherStep::SetTestFailure(TInt aError)
	{
	iError=aError;	
	}

void CWatcherStep::CheckMediaChangeL(TInt aChangeNumber, 
						TInt aExpectedDrive, TInt aExpectedChangeType, const TDesC& aDescription)
	{
	if (aChangeNumber != iNotifications.Count() ||
		iNotifications[aChangeNumber - 1].iDrive != aExpectedDrive ||
		iNotifications[aChangeNumber - 1].iChangeType != aExpectedChangeType)
		{
		SetTestStepResult(EFail);
		ERR_PRINTF2(_L("Error, expected change %S"), &aDescription);
		User::Leave(KErrGeneral);
		}
	}

void CWatcherStep::MediaChangeL(TInt aDrive, TChangeType aChangeType)
	{
	iNotifications.AppendL(TNotification(aDrive,aChangeType));	
	
	if (iActiveStep)
		{
		iActiveStep->NotifyMediaChange();
		}
	}

// CWatcherStep::TNotification

CWatcherStep::TNotification::TNotification(TInt aDrive, TChangeType aChangeType)
	:iDrive(aDrive), iChangeType(aChangeType)
	{
	}

	
// CWatcherActiveStep

/*static*/ CWatcherActiveStep* CWatcherActiveStep::NewL(CWatcherStep& aWatcherStep, TInt aPriority)
	{
	CWatcherActiveStep* self=NewLC(aWatcherStep, aPriority);
	CleanupStack::Pop(self);
	return self;
	}

/*static*/ CWatcherActiveStep* CWatcherActiveStep::NewLC(CWatcherStep& aWatcherStep, TInt aPriority)
	{
	CWatcherActiveStep* self=new(ELeave) CWatcherActiveStep(aWatcherStep, aPriority);
	CleanupStack::PushL(self);
	self->ConstructL();
	return self;	
	}

CWatcherActiveStep::CWatcherActiveStep(CWatcherStep& aWatcherStep, TInt aPriority)
	: CActive(aPriority), iWatcherStep(aWatcherStep), iMediaChange(EFalse)
	{
	CActiveScheduler::Add(this);
	}

void CWatcherActiveStep::ConstructL()
	{
	User::LeaveIfError(iFs.Connect());
	}
	
CWatcherActiveStep::~CWatcherActiveStep()
	{
	delete iDriveWatcherX;
	iFs.Close();
	}

void CWatcherActiveStep::StartTest()
	{
	//  setup state
	iTestState=EStateStartup;
	WaitForNotify();
	TRequestStatus* status=&iStatus;
	User::RequestComplete(status, KErrNone);
	
	// start new level of scheduler
	CActiveScheduler::Start();
	}

void CWatcherActiveStep::DoCancel()
	{
	}

void CWatcherActiveStep::RunL()
	{
	if (iTestState==EStateFinish)
		{
		Deque();
		CActiveScheduler::Stop();
		return;
		}

	if (iMediaChange)
		{
		iMediaChange=EFalse;
		CheckResults();
		}
	else
		{
		RunTestsL();
		}
	}

void CWatcherActiveStep::RunTestsL()
	{
		switch (iTestState)
		{
		case EStateStartup:	// Startup, test initial notify.
			{
			WaitForNotify();
			iDriveWatcherX=CDriveWatcher::NewL(iFs, KDriveE, iWatcherStep);
			break;
			}
		case EStateTestNotify:	// Test notification which should apply to a watched drive
			{
			WaitForNotify();
			GenerateMediaChangeL(_L("E:\\private\\10202DCE\\mediachange\\"));
			break;
			}
			
		case EStateTestNotify2:
			{
			WaitForNotify();
			TRAPD(err, GenerateMediaChangeL(_L("A:\\private\\10202DCE\\mediachange\\")));
			if (err!=KErrNotReady && err!=KErrNone)
				{
				User::Leave(err);
				}

			TRAP(err, GenerateMediaChangeL(_L("B:\\private\\10202DCE\\mediachange\\")));
			if (err!=KErrNotReady && err!=KErrNone)
				{
				User::Leave(err);
				}
			
			_LIT(KPath ,"\\private\\10202DCE\\mediachange\\");
			TDriveUnit sysDrive (RFs::GetSystemDrive());
			TBuf<128> mediaChangePath (sysDrive.Name());
			mediaChangePath.Append(KPath);
			
			TRAP(err, GenerateMediaChangeL(mediaChangePath));
			if (err!=KErrNotReady && err!=KErrNone)
				{
				User::Leave(err);
				}
			
			TRAP(err, GenerateMediaChangeL(_L("D:\\private\\10202DCE\\mediachange\\")));
			if (err!=KErrNotReady && err!=KErrNone)
				{
				User::Leave(err);
				}

			GenerateMediaChangeL(_L("E:\\private\\10202DCE\\mediachange\\"));
			break;
			}
		}
	}

void CWatcherActiveStep::CheckResults()
	{
	switch (iTestState)
		{
		case EStateStartup:	// Startup, test initial notify.
			{
			iWatcherStep.CheckMediaChangeL(1, KDriveE, MDriveObserver::EMediaInserted, _L("Expect EMediaInserted at creation time"));
			RunNextTest(EStateTestNotify);
			break;
			}

		case EStateTestNotify:	// test notify.
			{
			iWatcherStep.CheckMediaChangeL(2, KDriveE, MDriveObserver::EMediaInserted, _L("Expect EMediaInserted"));
			RunNextTest(EStateTestNotify2);
			break;
			}
			
		case EStateTestNotify2:	// test notify.
			{
			iWatcherStep.CheckMediaChangeL(3, KDriveE, MDriveObserver::EMediaInserted, _L("Expect EMediaInserted"));
			RunNextTest(EStateFinish);
			break;
			}
		}
	}

TInt CWatcherActiveStep::RunError(TInt aError)
	{
	if (aError==KErrGeneral)
		{
		RunNextTest(EStateFinish);
		return KErrNone;			
		}
	else
		{
		SetTestFailure(aError);
		return KErrNone;
		}
	}

void CWatcherActiveStep::SetTestFailure(TInt aError)
	{
	iWatcherStep.SetTestFailure(aError);
	}

void CWatcherActiveStep::NotifyMediaChange()
	{
	TRequestStatus* status=&iStatus;
	User::RequestComplete(status, KErrNone);
	iMediaChange=ETrue;
	}

void CWatcherActiveStep::WaitForNotify()
	{
	iStatus=KRequestPending;
	SetActive();
	}

void CWatcherActiveStep::RunNextTest(TTestState aNextState)
	{
	iTestState=aNextState;
	WaitForNotify();
	TRequestStatus* status=&iStatus;
	User::RequestComplete(status, KErrNone);
	}


} // namespace Swi::Test

} //namespace Swi