// Copyright (c) 2002-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:

// This program is designed the test of the MMF_ACLNT.

// 

//

/**

 @file TestPlayerUtils.cpp

*/

#include "TestPlayerUtils.h"

#include <caf/caf.h>

// constant table of parameters for tests

const TRepeatParameters KTestParameters[] =

{	

	{ _S("playerAudioFile"), 1, 1},

	{ _S("Pcm16Mono12khz"), 3, 3},

	{ _S("PCM8"), 3, 3},

	{ _S("PCM8-6144bytes"), 1, 1},

	{ _S("ALAW"), 3, 3},

	{ _S("PCM16"), 1, 1},

	{ _S("PCMU8"), 2, 2},

	{ _S("PCMU16BE"), 3, 3},

	{ _S("PCMU16"), 1, 1},

	{ _S("MULAW"), 2, 2},

	{ _S("Sequence1"), 2, 2},

	{ _S("Sequence2"), 3, 3},

	{ _S("IMAD"), 3, 3},

	{ _S("GSM610"), 1, 1},

	{ _S("Pcm8Mono44khz"), 2, 2},

	{ _S("Pcm16Mono44khz"), 3, 3},

	{ _S("Pcm16Mono48khz"), 1, 1},

	{ _S("100khzSRate1KhzTone"), 2, 2},

	{ _S("Pcm16Mono24khz"), 3, 3},

	{ _S("playerAudioFile2"), 2, 2}

};

const TInt KNoOfTestFiles = 20;

TAny	GetDriveName(TDes& aFileName)

{

#ifdef __WINS__

	aFileName = _L("c:");	

#elif defined(__MARM__) || defined(__X86GCC__)

	#ifdef __TEST_FILES_ON_C_DRIVE__

		aFileName = _L("c:");

	#else

		aFileName = _L("z:");	

	#endif // __TEST_FILES_ON_C_DRIVE__

#endif	

}

#define STOP_TEST_GEN_ERROR ERR_PRINTF1(_L("State machine error")), StopTest(KErrGeneral, EFail)

/**

 * Constructor

 */

CTestMmfAclntFile::CTestMmfAclntFile(const TDesC& aTestName,const TDesC& aSectName,

									 const TDesC& aKeyName,const TBool aPlay, 

									 const TInt aExpectedError)

	:iPlay (aPlay)

	,iExpectedError (aExpectedError)

	{

	// store the name of this test case

	// this is the name that is used by the script file

	// Each test step initialises it's own name

	iTestStepName = aTestName;

	iSectName = aSectName;

	iKeyName = aKeyName;

	}

CTestMmfAclntFile* CTestMmfAclntFile::NewL(const TDesC& aTestName, const TDesC& aSectName,

										   const TDesC& aKeyName,const TBool aPlay, 

										   const TInt aExpectedError = KErrNone)

	{

	CTestMmfAclntFile* self = new (ELeave) CTestMmfAclntFile(aTestName,aSectName,aKeyName,aPlay,aExpectedError);

	return self;

	}

CTestMmfAclntFile* CTestMmfAclntFile::NewLC(const TDesC& aTestName, const TDesC& aSectName,

											const TDesC& aKeyName,

											const TBool aPlay,  

											const TInt aExpectedError)

	{

	CTestMmfAclntFile* self = CTestMmfAclntFile::NewL(aTestName,aSectName,aKeyName,aPlay,aExpectedError);

	CleanupStack::PushL(self);

	return self;

	}

void CTestMmfAclntFile::MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds &aDuration)

	{

	iError = aError;

	iDuration = aDuration;

	INFO_PRINTF1( _L("MMdaAudioPlayerCallback Init Complete"));

	CActiveScheduler::Stop();

	}

void CTestMmfAclntFile::MapcPlayComplete(TInt aError)

	{

	iError = aError;

	INFO_PRINTF1(_L("MMdaAudioPlayerCallback Play Complete"));

	CActiveScheduler::Stop();

	}

/** Load and initialise an audio file.

 */

TVerdict CTestMmfAclntFile::DoTestStepL( void )

	{

	INFO_PRINTF1( _L("TestPlayerUtils : File"));

	TVerdict ret = EFail;

	iError = KErrTimedOut;

	TBuf<KSizeBuf>	filename;

	TPtrC			filename1; 

	if(!GetStringFromConfig(iSectName,iKeyName,filename1))

		{

		return EInconclusive;

		}

	GetDriveName(filename);

	filename.Append(filename1);

	CMdaAudioPlayerUtility* player = NULL;

	INFO_PRINTF2(_L("CMdaAudioPlayerUtility::NewFilePlayerL() - %S"), &filename);

	player = CMdaAudioPlayerUtility::NewFilePlayerL(filename, *this);

	if (iTestStepName.Compare(_L("MM-MMF-ACLNT-I-2001-HP"))==0)

		{

		// Check file size is more than 0

		RFs fs;

		TInt err = fs.Connect();

		if (err != KErrNone)

			{

			INFO_PRINTF2(_L("Error connecting to file session (%d)"), err);

			return EInconclusive;

			}

		CleanupClosePushL(fs);

		TEntry fileEntry;

		err = fs.Entry(filename, fileEntry);

		if (err != KErrNone)

			{

			INFO_PRINTF2(_L("Error getting file entry (%d)"), err);

			fs.Close();

			return EInconclusive;

			}

		if (fileEntry.iSize <= 0)

			{

			INFO_PRINTF2(_L("Test file '%S' has size %d"), fileEntry.iSize);

			fs.Close();

			return EInconclusive;

			}

		CleanupStack::PopAndDestroy();	// fs

		}

#ifndef __WINS__

	if (iTestStepName.Compare(_L("MM-MMF-ACLNT-I-2014-LP")) == 0)

		{

		// this test should not be run on Lubbock

		INFO_PRINTF1(_L("Lubbock hardware is not fast enough to convert 100KHz audio."));

		INFO_PRINTF1(_L("This test has been skipped for this reason..."));

		delete player;

		User::After(KOneSecond); // wait for deletion to shut down devsound

		return EPass;

		}

#endif

	// Wait for initialisation callback

	INFO_PRINTF1( _L("Initialise CMdaAudioPlayerUtility"));

	CActiveScheduler::Start();

	if(iError != KErrNone && (iExpectedError == iError))

		{

		if (iTestStepName.Compare(_L("MM-MMF-ACLNT-I-1008-HP")) == 0)

			{

			// Test is for non-existent file - check that the file has not been created

			RFs fs;

			TInt err = fs.Connect();

			if (err != KErrNone)

				{

				ret = EInconclusive;

				}

			else

				{

				TEntry entry;

				if (fs.Entry(filename, entry) == KErrNone)

					{

					ret = EFail;	// file exists - test fails

					}

				else

					ret = EPass;

				fs.Close();

				}

			}

		else

			{

			ret = EPass;	// all other tests pass

			}

		delete player;

		User::After(KOneSecond); // wait for deletion to shut down devsound

		ERR_PRINTF2( _L("CMdaAudioPlayerUtility failed with expectable error %d"),iError );

		return ret;

		}

	// Check for errors.

	if (iError == KErrNone && player != NULL)

		{

		if(iPlay)

			{

			iError = KErrTimedOut;

			player->Play();

			// Wait for init callback

			INFO_PRINTF1( _L("Play CMdaAudioPlayerUtility"));

			CActiveScheduler::Start();

			//can't use iExpected Error as is doesn't distinguish between 

			//error from NewFilePlayerL or PlayL.

			if ((iTestStepName.Compare(_L("MM-MMF-ACLNT-I-2015-LP")) == 0))

				{

				if(iError == KErrNotSupported)

					{

					ret = EPass;

					}

				}

			else if(iError == KErrNone)

				ret = EPass;

			}

		else

			ret = EPass;			

		}

	delete player;

	User::After(KOneSecond); // wait for deletion to shut down devsound

	if(iError != KErrNone)

		{

		if ((iTestStepName.Compare(_L("MM-MMF-ACLNT-I-2014-LP")) == 0) && iError==KErrNotSupported)

			{

			//Sampling Rate greater than 96000 Hz is not expected in data , and we dont support this.

			//This test has been changed to expect KErrNotSupported due to fix in PDEF131534 

			INFO_PRINTF1( _L("CMdaAudiPlayerUtility returned KErrNotSupported as expected"));

			ret= EPass;

			}

		else

			{

			ERR_PRINTF2( _L("CMdaAudioPlayerUtility failed with error %d"),iError );

			}

		}

	return	ret;

	}

/**

 * Constructor

 */

CTestMmfAclntSEQNFile::CTestMmfAclntSEQNFile(const TDesC& aTestName,const TDesC& aSectName,

									 const TDesC& aKeyName,

									 const TBool aPlay, 

									 const TBool aIsFile)

	:iPlay (aPlay)

	,iIsFile (aIsFile)

	{

	// store the name of this test case

	// this is the name that is used by the script file

	// Each test step initialises it's own name

	iTestStepName = aTestName;

	iSectName = aSectName;

	iKeyName = aKeyName;

	}

CTestMmfAclntSEQNFile* CTestMmfAclntSEQNFile::NewL(const TDesC& aTestName, const TDesC& aSectName,

										   const TDesC& aKeyName,

										   const TBool aPlay, 

										   const TBool aIsFile)

	{

	CTestMmfAclntSEQNFile* self = new (ELeave) CTestMmfAclntSEQNFile(aTestName,aSectName,aKeyName,aPlay,aIsFile);

	return self;

	}

CTestMmfAclntSEQNFile* CTestMmfAclntSEQNFile::NewLC(const TDesC& aTestName, const TDesC& aSectName,

											const TDesC& aKeyName,

											const TBool aPlay,  

											const TBool aIsFile)

	{

	CTestMmfAclntSEQNFile* self = CTestMmfAclntSEQNFile::NewL(aTestName,aSectName,aKeyName,aPlay,aIsFile);

	CleanupStack::PushL(self);

	return self;

	}

void CTestMmfAclntSEQNFile::MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds &aDuration)

	{

	iError = aError;

	iDuration = aDuration;

	INFO_PRINTF1( _L("MMdaAudioPlayerCallback Init Complete"));

	CActiveScheduler::Stop();

	}

void CTestMmfAclntSEQNFile::MapcPlayComplete(TInt aError)

	{

	iError = aError;

	INFO_PRINTF1( _L("MMdaAudioPlayerCallback Play Complete"));

	CActiveScheduler::Stop();

	}

//This method is used to stop playing the file 1 second after we started

void CTestMmfAclntSEQNFile::DelayedMethodCallL()

{

CActiveScheduler::Stop();

}

/** Load and play an audio sequence file.

 */

TVerdict CTestMmfAclntSEQNFile::DoTestStepL( void )

	{

	INFO_PRINTF1( _L("TestPlayerUtils : File"));

	TVerdict ret = EFail;

	iError = KErrTimedOut;

	TBuf<KSizeBuf>	filename;

	TPtrC			filename1; 

	if(!GetStringFromConfig(iSectName,iKeyName,filename1))

		{

		return EInconclusive;

		}

	GetDriveName(filename);

	filename.Append(filename1);

	CMdaAudioPlayerUtility* player = NULL;

	HBufC8* seqnDesc = NULL;

	RFile file;

	RFs fs;

	if(iIsFile)

		{

		player = CMdaAudioPlayerUtility::NewFilePlayerL(filename, *this);

		}

	else

		{

		User::LeaveIfError(fs.Connect());

//TIMB

		User::LeaveIfError(file.Open(fs, filename, EFileShareReadersOnly | EFileStream));

		CleanupClosePushL(file);

		TInt size;

		User::LeaveIfError(file.Size(size));

		seqnDesc = HBufC8::NewMaxLC(size);

		TPtr8 bufferDes(seqnDesc->Des());

		User::LeaveIfError(file.Read(bufferDes));

		player = CMdaAudioPlayerUtility::NewDesPlayerL(bufferDes, *this);

		}

	CleanupStack::PushL(player);

	// Wait for initialisation callback

	INFO_PRINTF1( _L("Initialise CMdaAudioPlayerUtility"));

	CActiveScheduler::Start();

	if(iError == KErrNone)

		{

		TInt maxVol = player->MaxVolume();

		player->SetVolume(maxVol/2);

		TInt gotVol;

		iError = player->GetVolume(gotVol);

		if((iError != KErrNone) || (maxVol/2 != gotVol))

			{

			ERR_PRINTF1( _L("CMdaAudioPlayerUtility failed volume tests"));

			if(iError == KErrNone)

				iError = KErrGeneral;

			}

		}

	if(iError == KErrNone)

		{

		TTimeIntervalMicroSeconds t(0);

		TTimeIntervalMicroSeconds zeroUs(0);

		t = player->Duration();

		if(t != zeroUs)

			{

			ERR_PRINTF1( _L("CMdaAudioPlayerUtility failed duration test"));

			iError = KErrGeneral;

			}

		player->SetPosition(zeroUs);

		iError = player->GetPosition(t);

		if((t != zeroUs) || (iError != KErrNone))

			{

			ERR_PRINTF1( _L("CMdaAudioPlayerUtility failed duration test"));

			if(iError == KErrNone)

				iError = KErrGeneral;

			}

		}

	if(iError == KErrNone)

		{

		TInt entries;

		TInt metaErr = KErrNone;

		metaErr = player->GetNumberOfMetaDataEntries(entries);

		if(metaErr != KErrNotSupported)

			{

			ERR_PRINTF1( _L("CMdaAudioPlayerUtility failed volume tests"));

			iError = metaErr;

			}

		else

			{

			CMMFMetaDataEntry* metaEntry = NULL;	// EABI warning removal - "metaEntry was set but never used"

			TRAP(metaErr, metaEntry = player->GetMetaDataEntryL(0));	// EABI warning removal - "metaEntry was set but never used"

			if(metaErr != KErrNotSupported)

				{

				ERR_PRINTF1( _L("CMdaAudioPlayerUtility failed volume tests"));

				iError = metaErr;

				if (metaErr==KErrNone)

					{

					delete metaEntry;

					}

				}

			}

		}

	if(iError == KErrNone)

		{

		player->SetBalance(KMMFBalanceMaxLeft);

		TInt bal = KMMFBalanceCenter;

		iError = player->GetBalance(bal);

		if(bal != KMMFBalanceMaxLeft)

			{

			ERR_PRINTF1( _L("CMdaAudioPlayerUtility failed balance tests"));

			if(iError == KErrNone)

				iError = KErrGeneral;

			}

		else

			player->SetBalance(KMMFBalanceCenter);

		}

	if(iError == KErrNone)

		{

		TInt priErr = player->SetPriority(EMdaPriorityMin, EMdaPriorityPreferenceNone);

		if(priErr != KErrNone)

			{

			ERR_PRINTF1( _L("CMdaAudioPlayerUtility failed priority tests"));

			iError = KErrGeneral;

			}

		else

			player->SetPriority(EMdaPriorityNormal, EMdaPriorityPreferenceNone);

		}

	if(iError == KErrNone)

		{

		iError = KErrTimedOut;

		player->Play();

		//Stop the player after one second and restart

		CDelayedMethodCall* delayedMethodCall = CDelayedMethodCall::NewL(this);

		CleanupStack::PushL(delayedMethodCall);

		delayedMethodCall->After(KOneSecond);

		CActiveScheduler::Start();

		CleanupStack::PopAndDestroy(delayedMethodCall);

		player->Stop();

		player->Play();

		CActiveScheduler::Start();

		}

	CleanupStack::PopAndDestroy(player);

	if(iIsFile == EFalse)

		{

		CleanupStack::PopAndDestroy(seqnDesc);

		CleanupStack::PopAndDestroy(&file);

		}

	User::After(KOneSecond); // wait for deletion to shut down devsound