// Copyright (c) 2000-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:
// TMDAVID1.CPP
// These tests are designed to perform multiple Media Server opertaions by using multiple threads
// each containing many active objects.
// 
//

#include "tmdatest.h"


/*********************************************************************************************/
class CStressTestMonitor : public CBase
	{
public:
	void IncActiveCount();
	void DecActiveCount();
	void SetError(TInt aError);
	TInt Error();
private:
	TInt iActiveCount;
	TInt iError;
	};

void CStressTestMonitor::IncActiveCount()
	{
	iActiveCount++;
	}

void CStressTestMonitor::DecActiveCount()
	{
	iActiveCount--;
	if(iActiveCount==0)
		CActiveScheduler::Stop();
	}

void CStressTestMonitor::SetError(TInt aError)
	{
	if(iError==KErrNone)
		iError = aError;
	}

TInt CStressTestMonitor::Error()
	{
	return(iError);
	}

/*********************************************************************************************/



/*********************************************************************************************/
class CStressTestActive : public CActive
	{
public:
	inline CStressTestActive(CStressTestMonitor& aMonitor) : CActive(EPriorityStandard), iMonitor(&aMonitor) { aMonitor.IncActiveCount(); }
	~CStressTestActive();
protected:
	// From CActive
	TInt RunError(TInt aError);
	// New
	void SetPending();
public:
	CStressTestMonitor* iMonitor;
	};

CStressTestActive::~CStressTestActive()
	{
	iMonitor->DecActiveCount();
	}

void CStressTestActive::SetPending()
	{
	if(!IsAdded())
		CActiveScheduler::Add(this);
	iStatus = KRequestPending;
	SetActive();
	}

TInt CStressTestActive::RunError(TInt aError)
	{
	iMonitor->SetError(aError);
	delete this;
	return KErrNone;
	}

/*********************************************************************************************/



/*********************************************************************************************/
class CImageUtil : public CStressTestActive, public MMdaImageUtilObserver
	{
public:
	inline CImageUtil(CStressTestMonitor& aMonitor) : CStressTestActive(aMonitor) {}
private:
	virtual void MiuoCreateComplete(TInt aError);
	virtual void MiuoOpenComplete(TInt aError);
	virtual void MiuoConvertComplete(TInt aError);
	};

void CImageUtil::MiuoCreateComplete(TInt aError)
	{
	TRequestStatus* status = &iStatus;
	User::RequestComplete(status,aError);
	}

void CImageUtil::MiuoOpenComplete(TInt aError)
	{
	TRequestStatus* status = &iStatus;
	User::RequestComplete(status,aError);
	}

void CImageUtil::MiuoConvertComplete(TInt aError)
	{
	TRequestStatus* status = &iStatus;
	User::RequestComplete(status,aError);
	}
/*********************************************************************************************/



/*********************************************************************************************/
class CImageLoadUtil : public CImageUtil
	{
public:
	static CImageLoadUtil* NewL(CStressTestMonitor& aMonitor,const TDesC& aFileName,const TDisplayMode aDisplayMode);
	~CImageLoadUtil();
private:
	inline CImageLoadUtil(CStressTestMonitor& aMonitor) : CImageUtil(aMonitor) {};
	void RunL();
	void DoCancel();
private:
	TBuf<255> iMessage;
	TDisplayMode iDisplayMode;
	CFbsBitmap* iBitmap;
	CMdaImageFileToBitmapUtility* iMdaUtil;
	TInt iState;
	};

CImageLoadUtil* CImageLoadUtil::NewL(CStressTestMonitor& aMonitor,const TDesC& aFileName,const TDisplayMode aDisplayMode)
	{
	CImageLoadUtil* ptr = new (ELeave) CImageLoadUtil(aMonitor);

	CleanupStack::PushL(ptr);

	ptr->iBitmap = new(ELeave) CFbsBitmap;
	ptr->iDisplayMode = aDisplayMode;

	ptr->iMdaUtil = CMdaImageFileToBitmapUtility::NewL(*ptr);

	ptr->iMessage.Append(_L("Loading image "));
	ptr->iMessage.Append(aFileName);

	ptr->iMdaUtil->OpenL(aFileName,NULL,NULL,NULL);

	CleanupStack::Pop();

	ptr->SetPending();

	return ptr;
	}

CImageLoadUtil::~CImageLoadUtil()
	{
	Cancel();
	delete iBitmap;
	delete iMdaUtil;
	}

void CImageLoadUtil::RunL()
	{
	TInt error = iStatus.Int();

	if(error==KErrNone)
		{
		if(!iState)
			{
			TFrameInfo frameInfo;
			iMdaUtil->FrameInfo(0,frameInfo);

			iBitmap->Reset();
			error = iBitmap->Create(frameInfo.iOverallSizeInPixels,iDisplayMode);
			if(error==KErrNone)
				{
				TRAP(error,iMdaUtil->ConvertL(*iBitmap));
				if(error==KErrNone)
					{
					iState++;
					SetPending();
					return;
					}
				}
			}
		}

	if(error!=KErrNone)
		{
		iMessage.AppendFormat(_L(" - Failed with error %d"),error);
		RDebug::Print(iMessage);
		User::Leave(error);
		}
	else
		{
		iMessage.AppendFormat(_L(" - Finished OK"));
		RDebug::Print(iMessage);
		}
	delete this;
	}

void CImageLoadUtil::DoCancel()
	{
	iMdaUtil->Cancel();
	}

/*********************************************************************************************/



/*********************************************************************************************/
GLDEF_C TInt TestStartupThread(TAny* /*aParam*/)
	{
	return KErrNone;
	}
/*********************************************************************************************/




/*********************************************************************************************/
void DoTestLoadImagesL(CMdaStressTestThread* aThread)
	{
	TInt err;

	 // Install active scheduler
	CActiveScheduler* as = new CActiveScheduler;
	__ASSERT_ALWAYS(as,User::Invariant());	
	CActiveScheduler::Install(as);
	CleanupStack::PushL(as);

	// Connect to file server
	RFs fs;
	err = fs.Connect();
	__ASSERT_ALWAYS(err == KErrNone, User::Invariant());
	CleanupClosePushL(fs);

	// Connect to FBS
	User::LeaveIfError(FbsStartup());
	User::LeaveIfError(RFbsSession::Connect());

	// Create monitor object
	CStressTestMonitor* monitor = new (ELeave) CStressTestMonitor;
	CleanupStack::PushL(monitor);

	CDir* dir = NULL;
	fs.GetDir(KNullDesC,0,0,dir);
	CleanupStack::PushL(dir);
	TInt entries = dir->Count();

	TDisplayMode displayMode;
	if(aThread->iId==CMdaStressTest::ELoadImages1)
		displayMode = EColor256;
	else
		displayMode = EGray4;

	entries--;
	while(entries>=0)
		{
		const TEntry& entry = (*dir)[entries];
		TFileName fileName;
		User::LeaveIfError(fs.DefaultPath(fileName));
		fileName.Append(entry.iName);
		CImageLoadUtil::NewL(*monitor,fileName,displayMode);
		entries -= 2;	// only load every other image to keep memory usage down
		}
	CleanupStack::PopAndDestroy();	// dir

	// Run active objects
	CActiveScheduler::Start();

	// Check for errors
	User::LeaveIfError(monitor->Error());

	// Close everything
	CleanupStack::PopAndDestroy(); // monitor
	RFbsSession::Disconnect();
	CleanupStack::PopAndDestroy(2); // fs and as
	}
/*********************************************************************************************/



/*********************************************************************************************/
GLDEF_C TInt TestLoadImages(TAny* aParam)
	{
	CTrapCleanup* tc = CTrapCleanup::New();
	__ASSERT_ALWAYS(tc,User::Invariant());	

	TRAPD(err,DoTestLoadImagesL(REINTERPRET_CAST(CMdaStressTestThread*,aParam)));

	delete tc;
	return err;
	}
/*********************************************************************************************/



/*********************************************************************************************/
CMdaStressTest::CMdaStressTest()
	: CMdaCoreTest(), iThreadList(_FOFF(CMdaStressTestThread,iLink)), iThreadIter(iThreadList), iRandomSeed(1)
	{
	}
/*********************************************************************************************/



/*********************************************************************************************/
CMdaStressTest::~CMdaStressTest()
	{
	// Delete all threads
	CMdaStressTestThread* thread;
	iThreadIter.SetToFirst();
	while ((thread=iThreadIter++)!=NULL)
		DeleteTestThread(thread);
	}
/*********************************************************************************************/



const TInt KThreadScanDelay = 200000;

/*********************************************************************************************/
void CMdaStressTest::DoTestL()
	{
	TInt error = KErrNone;
	TInt time = 10000000;
	TInt testNumber;
	CMdaStressTestThread* thread;

	// Launch test threads
	for(testNumber=0; testNumber<ENumTestThreads; testNumber++)
		StartTestThreadL(STATIC_CAST(TTestThreadId,testNumber));

	// Scan thread list
	do
		{
		TInt numThreads = 0;

		iThreadIter.SetToFirst();
		while ((thread=iThreadIter++)!=NULL)
			{
			if(thread->iThread.ExitType()==EExitPending)
				numThreads++;
			else
				{
				TInt reason = thread->iThread.ExitReason();
				if(reason!=KErrNone)
					{
					iEngine->TestFailed(reason);
					error = reason;
					break;
					}
				testNumber = thread->iId;
				DeleteTestThread(thread);
				StartTestThreadL(STATIC_CAST(TTestThreadId,testNumber));	// Restart test
				}
			}

		if(error)
			break;

		User::After(KThreadScanDelay);
		time -= KThreadScanDelay;
		}
	while(time>0);

//	iEngine->Print(_L("Waiting for test threads to end..."));

	// Wait for all threads to finish
	while(!iThreadList.IsEmpty())
		{
		User::After(KThreadScanDelay);
		// Delete all completed threads
		iThreadIter.SetToFirst();
		while ((thread=iThreadIter++)!=NULL)
			if(thread->iThread.ExitType()!=EExitPending)
				{
				TInt reason = thread->iThread.ExitReason();
				if(reason!=KErrNone)
					iEngine->TestFailed(reason);
				DeleteTestThread(thread);
				}
		}


	}
/*********************************************************************************************/



/*********************************************************************************************/
void CMdaStressTest::StartTestThreadL(TTestThreadId aId)
	{
	TThreadFunction function;

	switch(aId)
		{
		case ELoadImages1:
		case ELoadImages2:
			function = TestLoadImages;
			break;
		default:
			return;
		}

	TBuf<40> name;
	name.Append(_L("CMdaStressTestThread #"));
	name.AppendNum(aId,EDecimal);
	name.Append(_L("-"));
	name.AppendNum(iThreadNameCount++,EDecimal);

	CMdaStressTestThread* thread = new (ELeave) CMdaStressTestThread;
	CleanupStack::PushL(thread);

	thread->iId = aId;
	User::LeaveIfError(thread->iThread.Create(name, function, KDefaultStackSize, 1024, 2048*1024, thread));

	CleanupStack::Pop();

	iThreadList.AddLast(*thread);
	thread->iThread.Resume();
	}
/*********************************************************************************************/



/*********************************************************************************************/
void CMdaStressTest::DeleteTestThread(CMdaStressTestThread* thread)
	{
	if(thread->iThread.ExitType()==EExitPending)
		thread->iThread.Terminate(KErrNone);
	thread->iThread.Close();
	iThreadList.Remove(*thread);
	delete thread;
	}
/*********************************************************************************************/