// 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 TestTone.cpp
*/


#include "TestTone.h"

const TInt KHeapSizeToneTestEKA2 = 128000; // Heapsize for tone tests on EKA2

/**
 * Constructor
 */
CTestMmfAclntTone::CTestMmfAclntTone(const TDesC& aTestName, const TInt aExpectedResult)
	{
	// 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;
	
// need a bigger heap size on EKA2 HW
#if !defined __WINS__
	iHeapSize = KHeapSizeToneTestEKA2;
#endif // EKA2

	iFrequency = KToneFrequency;
	iDuration = TTimeIntervalMicroSeconds(KOneSecond);
	iExpectedResult = aExpectedResult;
	iStop = ETrue;
	}

CTestMmfAclntTone* CTestMmfAclntTone::NewL(const TDesC& aTestName, const TInt aExpectedResult)
	{
	CTestMmfAclntTone* self = new (ELeave) CTestMmfAclntTone(aTestName,aExpectedResult);
	return self;
	}

void CTestMmfAclntTone::MatoPrepareComplete(TInt aError)
	{
	iError = aError;
	INFO_PRINTF1( _L("CTestMmfAclntTone::MatoPrepareComplete MMdaAudioToneObserver Callback for CMdaAudioToneUtility complete"));
	INFO_PRINTF2( _L("iError %d"), iError);
	if(iStop)
		CActiveScheduler::Stop();
	}

void CTestMmfAclntTone::MatoPlayComplete(TInt aError)
	{
	iError = aError;
	INFO_PRINTF1( _L("CTestMmfAclntTone::MatoPlayComplete MMdaAudioToneObserver Callback for CMdaAudioToneUtility complete"));
	INFO_PRINTF2( _L("iError %d"), iError);
	if(iStop)
		CActiveScheduler::Stop();
	}

/**
 * Play a tone
 */
TVerdict CTestMmfAclntTone::DoTestStepL()
	{
	INFO_PRINTF1( _L("TestTone : Play"));

	iStop = ETrue;
	TVerdict ret = EFail;
	iError = KErrTimedOut;

	CMdaAudioToneUtility* toneUtil = CMdaAudioToneUtility::NewL(*this);
	CleanupStack::PushL(toneUtil);
	toneUtil->PrepareToPlayTone(iFrequency,iDuration);
	// Wait for prepare
	INFO_PRINTF1( _L("Initialise CMdaAudioToneUtility"));
	CActiveScheduler::Start();

	if(iError == KErrNone)
		ret = DoTestL(toneUtil);

	//produce another tone to confirm that the configuration is retained over multiple plays
	if(iError == KErrNone)
		ret = DoTestL(toneUtil);
	
	if(ret == EFail)
		ERR_PRINTF2( _L("CMdaAudioToneUtility failed with error %d"),iError );

	CleanupStack::PopAndDestroy(toneUtil);
	return	ret;
	}

TVerdict CTestMmfAclntTone::DoTestL(CMdaAudioToneUtility* aToneUtil)
	{
	TVerdict ret = EFail;
	iError = KErrTimedOut;
		
	aToneUtil->Play();
	// wait for play.
	INFO_PRINTF1( _L("Play CMdaAudioToneUtility"));
	CActiveScheduler::Start();

	if(iError == iExpectedResult)
		ret = EPass;
	
	return ret;
	}

//------------------------------------------------------------------

//Play DualTone Test for Sirocco CR
CTestMmfAclntDualTone::CTestMmfAclntDualTone(const TDesC& aTestName) 
	: CTestMmfAclntTone(aTestName) 
	{
	iFreqOne = KToneFrequency;
	iFreqTwo = KToneFrequencyTwo;
	}

CTestMmfAclntDualTone* CTestMmfAclntDualTone::NewL(const TDesC& aTestName)
	{
	CTestMmfAclntDualTone* self = new (ELeave) CTestMmfAclntDualTone(aTestName);
	return self;
	}


/**
 * Play a Dual tone
 */

TVerdict CTestMmfAclntDualTone::DoTestStepL()
	{
	INFO_PRINTF1( _L("TestTone : Play Dual Tone"));

	TVerdict ret = EFail;
	iError = KErrTimedOut;

	CMdaAudioToneUtility* toneUtil = CMdaAudioToneUtility::NewL(*this);
	CleanupStack::PushL(toneUtil);
	toneUtil->PrepareToPlayDualTone(iFreqOne,iFreqTwo,iDuration);
	
	// Wait for prepare
	INFO_PRINTF1( _L("Initialise CMdaAudioToneUtility"));
	CActiveScheduler::Start();

	if(iError == KErrNone)
		ret = DoTestL(toneUtil);

	//produce another tone to confirm that the configuration is retained over multiple plays
	if(iError == KErrNone)
		ret = DoTestL(toneUtil);
	
	if(ret == EFail)
		ERR_PRINTF2( _L("CMdaAudioToneUtility failed with error %d"),iError );

	CleanupStack::PopAndDestroy(toneUtil);
	return	ret;
	}

//------------------------------------------------------------------


CTestMmfAclntToneDtmf::CTestMmfAclntToneDtmf(const TDesC& aTestName,const TDesC& aDTMF,const TInt aExpectedResult)
	: CTestMmfAclntTone(aTestName,aExpectedResult), iDTMF(aDTMF)
	{}

CTestMmfAclntToneDtmf* CTestMmfAclntToneDtmf::NewL(const TDesC& aTestName,const TDesC& aDTMF,const TInt aExpectedResult)
	{
	CTestMmfAclntToneDtmf* self = new (ELeave) CTestMmfAclntToneDtmf(aTestName,aDTMF,aExpectedResult);
	return self;
	}

/**
 * Play a DTMF string
 */
TVerdict CTestMmfAclntToneDtmf::DoTestStepL()
	{
	INFO_PRINTF1( _L("TestTone : Play DTMF"));

	TVerdict ret = EFail;
	iError = KErrTimedOut;

	CMdaAudioToneUtility* toneUtil = CMdaAudioToneUtility::NewL(*this);
	CleanupStack::PushL(toneUtil);
	toneUtil->PrepareToPlayDTMFString(iDTMF);
	// Wait for prepare to complete
	INFO_PRINTF1( _L("Initialise CMdaAudioToneUtility"));
	CActiveScheduler::Start();

	toneUtil->PrepareToPlayDTMFString(iDTMF);
	// Wait for prepare to complete
	INFO_PRINTF1( _L("Reinitialise CMdaAudioToneUtility"));
	CActiveScheduler::Start();

	if(iError == KErrNone)
		ret = DoTestL(toneUtil);
	else if (iError == iExpectedResult)
		{
		INFO_PRINTF2( _L("Initialisation failed as expected with code %d"), iError);
		ret = EPass;
		iError = KErrNone;
		}
		
	if(ret == EFail)
		ERR_PRINTF2( _L("CMdaAudioToneUtility failed with error %d"),iError );

	CleanupStack::PopAndDestroy(toneUtil);
	return ret;
	}

//------------------------------------------------------------------

/**
 * Constructor
 */
CTestMmfAclntToneFile::CTestMmfAclntToneFile(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName)
	: CTestMmfAclntTone(aTestName)
	{
	// 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
	iSectName = aSectName;
	iKeyName= aKeyName;
	}

CTestMmfAclntToneFile* CTestMmfAclntToneFile::NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName)
	{
	CTestMmfAclntToneFile* self = new (ELeave) CTestMmfAclntToneFile(aTestName,aSectName,aKeyName);
	return self;
	}

TVerdict CTestMmfAclntToneFile::DoTestStepPreambleL()
	{
	TPtrC filename;
	if(!GetStringFromConfig(iSectName, iKeyName, filename))
		return EInconclusive;

	// Create a sequence file
	TInt length;
	RFs fs;

	fs.Connect();
	CleanupClosePushL(fs);
#ifdef __IPC_V2_PRESENT__
	User::LeaveIfError(fs.ShareAuto());
#else
	User::LeaveIfError(fs.Share(RSessionBase::EExplicitAttach));
#endif
	RFile file;
	User::LeaveIfError(file.Replace(fs,filename,EFileWrite));
	CleanupClosePushL(file);
	User::LeaveIfError(file.Write(KFixedSequenceData()));
	User::LeaveIfError(file.Size(length));
	CleanupStack::PopAndDestroy(2, &fs);

	return CTestMmfAclntStep::DoTestStepPreambleL();
	}

/**
 * Play a tone file
 */
TVerdict CTestMmfAclntToneFile::DoTestStepL( void )
	{
	INFO_PRINTF1( _L("TestTone : Play File"));

	TVerdict ret = EFail;


	TPtrC filename;
	if(!GetStringFromConfig(iSectName, iKeyName, filename))
		return EInconclusive;

	iError = KErrTimedOut;
	// perform test using this file
	CMdaAudioToneUtility* toneUtil = CMdaAudioToneUtility::NewL(*this);
	CleanupStack::PushL(toneUtil);
	toneUtil->PrepareToPlayFileSequence(filename);
	// Wait for prepare
	INFO_PRINTF1( _L("Initialise CMdaAudioToneUtility"));
	CActiveScheduler::Start();

	toneUtil->PrepareToPlayFileSequence(filename);
	// Wait for prepare
	INFO_PRINTF1( _L("re-initialise CMdaAudioToneUtility"));
	CActiveScheduler::Start();

	if(iError == KErrNone)
		ret = DoTestL(toneUtil);

	if(ret == EFail)
		ERR_PRINTF2( _L("CMdaAudioToneUtility failed with error %d"),iError );

	CleanupStack::PopAndDestroy(toneUtil);
	return ret;
	}

//------------------------------------------------------------------

/**
 * Constructor
 */
CTestMmfAclntToneDes::CTestMmfAclntToneDes(const TDesC& aTestName, const TDesC8& aDes, const TInt aExpectedResult)
	: CTestMmfAclntTone(aTestName, aExpectedResult), iDes(aDes)
	{}

CTestMmfAclntToneDes* CTestMmfAclntToneDes::NewL(const TDesC& aTestName, const TDesC8& aDes, const TInt aExpectedResult)
	{
	CTestMmfAclntToneDes* self = new (ELeave) CTestMmfAclntToneDes(aTestName,aDes, aExpectedResult);
	return self;
	}

/**
 * Play a tone from a descriptor.
 */
TVerdict CTestMmfAclntToneDes::DoTestStepL()
	{
	INFO_PRINTF1( _L("TestTone : Play Des"));

	TVerdict ret = EFail;
	iError = KErrTimedOut;

	CMdaAudioToneUtility* toneUtil = CMdaAudioToneUtility::NewL(*this);
	CleanupStack::PushL(toneUtil);
	toneUtil->PrepareToPlayDesSequence(iDes);
	// Wait for prepare
	INFO_PRINTF1( _L("Initialise CMdaAudioToneUtility"));
	CActiveScheduler::Start();

	toneUtil->PrepareToPlayDesSequence(iDes);
	// Wait for prepare
	INFO_PRINTF1( _L("re-initialise CMdaAudioToneUtility"));
	CActiveScheduler::Start();

	if(iError == KErrNone)
		ret = DoTestL(toneUtil);

	if(ret == EFail)
		ERR_PRINTF2( _L("CMdaAudioToneUtility failed with error %d"),iError );

	CleanupStack::PopAndDestroy(toneUtil);
	return ret;
	}

//------------------------------------------------------------------

/**
 * Constructor
 */
CTestMmfAclntToneFixed::CTestMmfAclntToneFixed(const TDesC& aTestName,const TInt aTone)
	:CTestMmfAclntTone(aTestName), iTone(aTone)
	{}

CTestMmfAclntToneFixed* CTestMmfAclntToneFixed::NewL(const TDesC& aTestName,const TInt aTone)
	{
	CTestMmfAclntToneFixed* self = new (ELeave) CTestMmfAclntToneFixed(aTestName,aTone);
	return self;
	}

/**
 * Play a predefined/fixed tone
 */
TVerdict CTestMmfAclntToneFixed::DoTestStepL()
	{
	#ifdef SYMBIAN_MULTIMEDIA_A3FDEVSOUND
		INFO_PRINTF1( _L("TestTone : Play Fixed - no longer supported"));

		TVerdict ret = EFail;
		iError = KErrTimedOut;

		CMdaAudioToneUtility* toneUtil = CMdaAudioToneUtility::NewL(*this);
		CleanupStack::PushL(toneUtil);
		toneUtil->PrepareToPlayFixedSequence(iTone);
		// Wait for prepare
		INFO_PRINTF1( _L("Initialise CMdaAudioToneUtility"));
		CActiveScheduler::Start();

		toneUtil->PrepareToPlayFixedSequence(iTone);
		// Wait for prepare
		INFO_PRINTF1( _L("re-initialise CMdaAudioToneUtility"));
		CActiveScheduler::Start();

		// Has Audio Utility intialisied ?
		TInt sequenceCount = toneUtil->FixedSequenceCount();
		INFO_PRINTF2( _L("FixedSequenceCount() returned %d"),sequenceCount);
		if(sequenceCount <= 0)
			{
			INFO_PRINTF1( _L("Play Fixed Sequence is no longer supported"));
			ret = EPass;
			}

		if(ret == EFail)
			ERR_PRINTF2( _L("CMdaAudioToneUtility failed with error %d"),iError );

		CleanupStack::PopAndDestroy(toneUtil);
		return ret;
		
	#else
		INFO_PRINTF1( _L("TestTone : Play Fixed"));

		TVerdict ret = EFail;
		iError = KErrTimedOut;

		CMdaAudioToneUtility* toneUtil = CMdaAudioToneUtility::NewL(*this);
		CleanupStack::PushL(toneUtil);
		toneUtil->PrepareToPlayFixedSequence(iTone);
		// Wait for prepare
		INFO_PRINTF1( _L("Initialise CMdaAudioToneUtility"));
		CActiveScheduler::Start();

		toneUtil->PrepareToPlayFixedSequence(iTone);
		// Wait for prepare
		INFO_PRINTF1( _L("re-initialise CMdaAudioToneUtility"));
		CActiveScheduler::Start();

		// Has Audio Utility intialisied ?
		TInt sequenceCount = toneUtil->FixedSequenceCount() ;
		if((iError == KErrNone) && (sequenceCount > 0))
			{
			INFO_PRINTF2( _L("FixedSequenceName is %S"), &toneUtil->FixedSequenceName(sequenceCount - 1)) ;
			ret = DoTestL(toneUtil);
			}

		if(ret == EFail)
			ERR_PRINTF2( _L("CMdaAudioToneUtility failed with error %d"),iError );

		CleanupStack::PopAndDestroy(toneUtil);
		return ret;
	#endif
	}
//------------------------------------------------------------------

/**
 * Constructor
 */
CTestMmfAclntToneAudio::CTestMmfAclntToneAudio()
	{
	// 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 = _L("MM-MMF-ACLNT-I-0156-LP");
	
// this test does not inherit from CTestMmfAclntTone
// so we need to make the heap bigger here	
// need a bigger heap size on EKA2 HW
#if !defined __WINS__
	iHeapSize = KHeapSizeToneTestEKA2;
#endif // EKA2
	}

void CTestMmfAclntToneAudio::MatoPrepareComplete(TInt aError)
	{
	iToneError = aError;
	INFO_PRINTF1( _L("CTestMmfAclntToneAudio::MatoPrepareComplete MMdaAudioToneObserver Callback for CMdaAudioToneUtility complete"));
	INFO_PRINTF2( _L("iToneError %d"), iToneError);
	CActiveScheduler::Stop();
	}

void CTestMmfAclntToneAudio::MatoPlayComplete(TInt aError)
	{
	INFO_PRINTF1( _L("CTestMmfAclntToneAudio::MatoPlayComplete MMdaAudioToneObserver Callback for CMdaAudioToneUtility called"));
	iToneError = aError;
	INFO_PRINTF2( _L("iToneError %d"), iToneError);

	if((--iCallbackCount) == 0)
		CActiveScheduler::Stop();
	}

void CTestMmfAclntToneAudio::MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds& /*aDuration*/)
	{
	iPlayerError = aError;
	CActiveScheduler::Stop();
	}	

void CTestMmfAclntToneAudio::MapcPlayComplete(TInt aError)
	{
	INFO_PRINTF1( _L("CTestMmfAclntToneAudio::MatcPlayComplete MMdaAudioPlayerCallback for CMdaAudioPlayerUtility called"));
	iPlayerError = aError;
	INFO_PRINTF2( _L("iPlayerError %d"), iPlayerError);

	if((--iCallbackCount) == 0)
		CActiveScheduler::Stop();
	}

//------------------------------------------------------------------

/**
 * Playing a tone and playing an audio file.
 */
TVerdict CTestMmfAclntToneAudio::DoTestStepL( void )
	{
	INFO_PRINTF1( _L("TestTone : Tone/File"));

	TBuf<KSizeBuf>	filename;
	TPtrC			filename1; 
	if(!GetStringFromConfig(_L("SectionOne"), _L("playerAudioFile"), filename1))
		return EInconclusive;

	GetDriveName(filename);
	filename.Append(filename1);
	
	iPlayerError = KErrTimedOut;
	CMdaAudioPlayerUtility* playerUtility = 
		//CMdaAudioPlayerUtility::NewFilePlayerL(filename,*this);//, EPriorityHigh);
		CMdaAudioPlayerUtility::NewFilePlayerL(filename,*this, EPriorityNormal);

	CleanupStack::PushL(playerUtility);
	
	// Wait for prepare
	INFO_PRINTF1( _L("Initialise CMdaAudioPlayerUtility"));
	CActiveScheduler::Start();

	if(iPlayerError == KErrNone)
		{
		iToneError = KErrTimedOut;
		INFO_PRINTF1( _L("Create audio tone utility..."));
		CMdaAudioToneUtility* toneUtil = CMdaAudioToneUtility::NewL(*this);
		CleanupStack::PushL(toneUtil);
		
		INFO_PRINTF1( _L("Prepare to play tone..."));
		toneUtil->PrepareToPlayTone(KToneFrequency,TTimeIntervalMicroSeconds(KOneSecond));
		// Wait for prepare
		INFO_PRINTF1( _L("Initialise CMdaAudioToneUtility"));
		CActiveScheduler::Start();

		INFO_PRINTF1( _L("Re-prepare to play tone..."));
		toneUtil->PrepareToPlayTone(KToneFrequency,TTimeIntervalMicroSeconds(KOneSecond));
		// Wait for prepare
		INFO_PRINTF1( _L("Initialise CMdaAudioToneUtility"));
		CActiveScheduler::Start();

		toneUtil->SetPriority(EPriorityHigh, EMdaPriorityPreferenceNone);
		if(iToneError == KErrNone)
			{
			iPlayerError = KErrTimedOut;
			iToneError = KErrTimedOut;

			// play files together
			INFO_PRINTF1( _L("Play CMdaAudioPlayerUtility"));
			playerUtility->Play();
			INFO_PRINTF1( _L("Play CMdaAudioToneUtility"));
			toneUtil->Play();

			iCallbackCount = 2;
			CActiveScheduler::Start();
			// Wait for two callbacks

			//Tone utility is at priority high - should complete normally
			//Player is at priority normal should complete with KErrInUse
			//KErrAccessDenied is OK here, at least until we can do Mixing
			if(iToneError==KErrNone && (iPlayerError==KErrInUse || iPlayerError==KErrNone))
				{
				CleanupStack::PopAndDestroy(2); // playerUtility, toneUtil
				return EPass;
				}
			}
		CleanupStack::PopAndDestroy(toneUtil);
		}
	else
		INFO_PRINTF1( _L("Cannot initialise CMdaAudioPlayerUtility"));

	ERR_PRINTF2( _L("CMdaAudioToneUtility completed with player error %d"),iPlayerError );
	ERR_PRINTF2( _L("CMdaAudioToneUtility completed with tone error %d"),iToneError );
	CleanupStack::PopAndDestroy(playerUtility);
	return EFail;
	}

//------------------------------------------------------------------

/** Constructor
 */
CTestMmfAclntToneCancelP::CTestMmfAclntToneCancelP(const TDesC& aTestName)
	:CTestMmfAclntTone(aTestName)
	{}

CTestMmfAclntToneCancelP* CTestMmfAclntToneCancelP::NewL(const TDesC& aTestName)
	{
	CTestMmfAclntToneCancelP* self = new (ELeave) CTestMmfAclntToneCancelP(aTestName);
	return self;
	}

/**
 * Cancel tone play
 */
TVerdict CTestMmfAclntToneCancelP::DoTestL(CMdaAudioToneUtility* aToneUtil)
	{
	INFO_PRINTF1( _L("TestTone : Cancel Play"));

	iStop = EFalse;
	TVerdict ret = EFail;

	aToneUtil->Play();
	INFO_PRINTF1( _L("Play CMdaAudioToneUtility"));
	if(aToneUtil->State() == EMdaAudioToneUtilityPlaying)
		{
		// cancel play.
		INFO_PRINTF1( _L("Cancel Play CMdaAudioToneUtility"));
		aToneUtil->CancelPlay();
		// make sure tone is no longer playing
		if(aToneUtil->State() != EMdaAudioToneUtilityPlaying)
			ret = EPass;
		}
	return ret;
	}

//------------------------------------------------------------------
/**
 * Constructor
 */
CTestMmfAclntToneCancelIni::CTestMmfAclntToneCancelIni(const TDesC& aTestName)
	:CTestMmfAclntTone(aTestName)
	{}

CTestMmfAclntToneCancelIni* CTestMmfAclntToneCancelIni::NewL(const TDesC& aTestName)
	{
	CTestMmfAclntToneCancelIni* self = new (ELeave) CTestMmfAclntToneCancelIni(aTestName);
	return self;
	}

/** 
 * Cancel tone prepare.
 * 
 * This fucntion cannot leave
 */
TVerdict CTestMmfAclntToneCancelIni::DoTestStepL()
	{
	INFO_PRINTF1( _L("TestTone : Cancel Prepare"));

	TVerdict ret = EFail;
	iError = KErrTimedOut;

	CMdaAudioToneUtility* toneUtil = CMdaAudioToneUtility::NewL(*this);
	CleanupStack::PushL(toneUtil);
	INFO_PRINTF1( _L("Initialise CMdaAudioToneUtility"));
	toneUtil->PrepareToPlayFixedSequence(0);
	INFO_PRINTF1( _L("Cancel Prep CMdaAudioToneUtility"));
	toneUtil->CancelPrepare();
	// make sure init callback did not complete
	if((iError == KErrTimedOut) && (toneUtil->State() != EMdaAudioToneUtilityPrepared))
		ret = EPass;

	if(ret == EFail)
		ERR_PRINTF2( _L("CMdaAudioToneUtility failed with error %d"),iError );

	CleanupStack::PopAndDestroy(toneUtil);
	return ret;
	}

//------------------------------------------------------------------

/**
 * Constructor
 */
CTestMmfAclntToneNames::CTestMmfAclntToneNames(const TDesC& aTestName)
	:CTestMmfAclntToneFixed(aTestName,1)
	{}

CTestMmfAclntToneNames* CTestMmfAclntToneNames::NewL(const TDesC& aTestName)
	{
	CTestMmfAclntToneNames* self = new (ELeave) CTestMmfAclntToneNames(aTestName);
	return self;
	}

/**
 * Enquire sequence name
 *
 * This function cannot leave
 */
TVerdict CTestMmfAclntToneNames::DoTestL(CMdaAudioToneUtility* aToneUtil)
	{
	INFO_PRINTF1( _L("TestTone : Seq Name"));

	TVerdict ret = EPass;
	TBuf<32> seqName;
	TInt count = aToneUtil->FixedSequenceCount();

	for(TInt i = 0; i < count; i++)
		{
		seqName = aToneUtil->FixedSequenceName(i);
		if(seqName.Length() < 1) 
			{
			ret = EFail;
			break;
			}
		}
	return ret;
	}

//------------------------------------------------------------------

/**
 * Constructor
 */
CTestMmfAclntToneCount::CTestMmfAclntToneCount(const TDesC& aTestName)
	:CTestMmfAclntToneFixed(aTestName,1)
	{}

CTestMmfAclntToneCount* CTestMmfAclntToneCount::NewL(const TDesC& aTestName)
	{
	CTestMmfAclntToneCount* self = new (ELeave) CTestMmfAclntToneCount(aTestName);
	return self;
	}

/**
 * Enquire sequence count
 */
TVerdict CTestMmfAclntToneCount::DoTestL(CMdaAudioToneUtility* aToneUtil)
	{
	INFO_PRINTF1( _L("TestTone : Seq Count"));

	iError = KErrTimedOut;

	if(aToneUtil->FixedSequenceCount() == KFixedSequenceCount)
		return EPass;

	return	EFail ;
	}

//------------------------------------------------------------------

/**
 * Constructor
 */
CTestMmfAclntToneVolume::CTestMmfAclntToneVolume(const TDesC& aTestName,const TInt aVolume)
	:CTestMmfAclntTone(aTestName), iVolume(aVolume)
	{}

CTestMmfAclntToneVolume* CTestMmfAclntToneVolume::NewL(const TDesC& aTestName,const TInt aVolume)
	{
	CTestMmfAclntToneVolume* self = new (ELeave) CTestMmfAclntToneVolume(aTestName,aVolume);
	return self;
	}

/**
 * Set volume to max and enquire volume
 */
TVerdict CTestMmfAclntToneVolume::DoTestL(CMdaAudioToneUtility* aToneUtil)
	{
	INFO_PRINTF1( _L("TestTone : Volume"));

	TVerdict ret = EFail;

	// added from CTestMmfAclntTone : we need the device to be open before
	// SetVolume() will function correctly

	aToneUtil->Play();
	// wait for play.
	INFO_PRINTF1( _L("Play CMdaAudioToneUtility"));

	// don't wait for it to finish - run this test while playing
	// so we know device is open

	// Check maxvolume function
	if(iVolume == -1)
		{
		iVolume = aToneUtil->MaxVolume();
		aToneUtil->SetVolume(iVolume);
		INFO_PRINTF3(_L("volume = %d iVolume = %d"), aToneUtil->Volume(), iVolume); 
		if(aToneUtil->Volume() == iVolume)
			ret = EPass;
		}
	// Volume is truncated to maxvolume
	if(iVolume > aToneUtil->MaxVolume())
		{
		aToneUtil->SetVolume(iVolume);
		INFO_PRINTF3(_L("volume = %d maxVolume = %d"), aToneUtil->Volume(), aToneUtil->MaxVolume()); 
		if(aToneUtil->Volume() == aToneUtil->MaxVolume())
			ret = EPass;
		}
	// Volume is truncated to 0
	else if(iVolume < 0)
		{
		aToneUtil->SetVolume(iVolume);
		INFO_PRINTF2(_L("volume = %d, expecting 0"), aToneUtil->Volume()); 
		if(aToneUtil->Volume() == 0)
			ret = EPass;
		}
	// Set volume and check
	else
		{
		aToneUtil->SetVolume(iVolume);
		INFO_PRINTF3(_L("volume = %d iVolume = %d"), aToneUtil->Volume(), iVolume); 
		if(aToneUtil->Volume() == iVolume)
			ret = EPass;
		}

	// let it finish playing
	CActiveScheduler::Start();

	return ret;
	}


//------------------------------------------------------------------

/**
 * Constructor
 */
CTestMmfAclntVolumeRamp::CTestMmfAclntVolumeRamp(const TDesC& aTestName, const TInt aRamp)
	:CTestMmfAclntTone(aTestName), iRamp(aRamp)
	{}

CTestMmfAclntVolumeRamp* CTestMmfAclntVolumeRamp::NewL(const TDesC& aTestName, const TInt aRamp)
	{
	CTestMmfAclntVolumeRamp* self = new (ELeave) CTestMmfAclntVolumeRamp(aTestName,aRamp);
	return self;
	}

/**
 * Set volume ramp
 * This function cannot leave
 */
TVerdict CTestMmfAclntVolumeRamp::DoTestL(CMdaAudioToneUtility* aToneUtil)
	{

	INFO_PRINTF1( _L("TestTone : Ramp"));

	TTimeIntervalMicroSeconds ramp(iRamp);
	aToneUtil->SetVolumeRamp(ramp);

	// aToneUtil->[Get]VolumeRamp() doesn't exist.
	// For now, if SetVolumeRamp() doesn't panic, we have to return EPass.
	// In future, maybe we can play the clip and get the volume at intervals?
	INFO_PRINTF1(_L("Warning : no API function to get volume ramp"));

	return EPass;
	}

//------------------------------------------------------------------

/**
 * Constructor
 */
CTestMmfAclntToneRepeat::CTestMmfAclntToneRepeat(const TDesC& aTestName)
	:CTestMmfAclntTone(aTestName)
	{}

CTestMmfAclntToneRepeat* CTestMmfAclntToneRepeat::NewL(const TDesC& aTestName)
	{
	CTestMmfAclntToneRepeat* self = new (ELeave) CTestMmfAclntToneRepeat(aTestName);
	return self;
	}

/**
 * Set repeats
 */
TVerdict CTestMmfAclntToneRepeat::DoTestL(CMdaAudioToneUtility* aToneUtil)
	{
	INFO_PRINTF1( _L("TestTone : Repeats"));

	iError = KErrTimedOut;

	TTimeIntervalMicroSeconds silence(0);
	aToneUtil->SetRepeats(NUMBER_OF_REPEATS,silence);

	TInt duration = I64INT(iDuration.Int64());

	iError = KErrTimedOut;
	INFO_PRINTF1( _L("Play CMdaAudioToneUtility"));
	aToneUtil->Play();

	TTime start;
	start.HomeTime();
	CActiveScheduler::Start();
	TTime stop;
	stop.HomeTime();

	TUint actualDuration = I64INT(stop.MicroSecondsFrom(start).Int64());

	INFO_PRINTF2(_L("Repeats : %d"), NUMBER_OF_REPEATS);
	INFO_PRINTF6(_L("Error : %d Start = %d Stop = %d Duration = %d ActualDuration = %d"),
		iError, I64INT(start.Int64()), I64INT(stop.Int64()), duration, actualDuration);

	if((iError == KErrNone) && (TimeComparison(actualDuration, duration * (NUMBER_OF_REPEATS + 1),
											   KExpectedDeviation * NUMBER_OF_REPEATS)))
		return EPass;

	return	EFail ;
	}

//------------------------------------------------------------------

/**
 * Constructor
 */
CTestMmfAclntToneLength::CTestMmfAclntToneLength(const TDesC& aTestName)
	:CTestMmfAclntToneDtmf(aTestName,KShortDTMFString)
	{}

CTestMmfAclntToneLength* CTestMmfAclntToneLength::NewL(const TDesC& aTestName)
	{
	CTestMmfAclntToneLength* self = new (ELeave) CTestMmfAclntToneLength(aTestName);
	return self;
	}

/**
 * Configure tone on length, tone off length, pause length of DTMF Tones
 */
TVerdict CTestMmfAclntToneLength::DoTestL(CMdaAudioToneUtility* aToneUtil)
	{
	INFO_PRINTF1( _L("TestTone : Length"));

	iError = KErrTimedOut;
	TTimeIntervalMicroSeconds32 on(KOneSecond), off(KOneSecond), pause(0);

	aToneUtil->SetDTMFLengths(on, off, pause);

	iError = KErrTimedOut;
	INFO_PRINTF1( _L("Play CMdaAudioToneUtility"));
	aToneUtil->Play();

	TTime start;
	start.HomeTime();
	CActiveScheduler::Start();
	TTime stop;
	stop.HomeTime();

	TUint actualDuration = I64INT(stop.MicroSecondsFrom(start).Int64());

	INFO_PRINTF6(_L("Error : %d Start = %d Stop = %d Duration = %d ActualDuration = %d"),
		iError, I64INT(start.Int64()), I64INT(stop.Int64()), KTwoSeconds, actualDuration);

	if((iError == KErrNone) && (TimeComparison(actualDuration, KTwoSeconds, KExpectedDeviation)))
		return EPass;

	return EFail ;
	}

//------------------------------------------------------------------

/**
 * Constructor
 */
CTestMmfAclntPriorityTones::CTestMmfAclntPriorityTones()
	{
	// 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 = _L("MM-MMF-ACLNT-I-0165-HP");
	}

void CTestMmfAclntPriorityTones::MchoComplete(TInt aID, TInt aError)
	{
	INFO_PRINTF1( _L("CTestMmfAclntPriorityTones : MMdaAudioToneObserver Callback for CMdaAudioToneUtility called"));
	iError = aError;
	INFO_PRINTF3( _L("iError %d ID %d"), iError, aID);

	if(iFirstCallback == -1)
		iFirstCallback = aID;

	if((--iCallbackCount) == 0)
		CActiveScheduler::Stop();
	}

/**
 * Set priorities of tones
 */
TVerdict CTestMmfAclntPriorityTones::DoTestStepL()
	{
	INFO_PRINTF1( _L("TestTone : Priorities"));

	iError = KErrTimedOut;

    CMdaAudioToneUtility* toneUtil[2];
	CToneCallbackHandler* callback[2];

	for(TInt i=0; i<2; i++)
		{
		callback[i] = new (ELeave) CToneCallbackHandler(i,this);
		CleanupStack::PushL(callback[i]);
		}
	
	toneUtil[0] = CMdaAudioToneUtility::NewL(*callback[0],NULL, -10, EMdaPriorityPreferenceTimeAndQuality);
	CleanupStack::PushL(toneUtil[0]);
	toneUtil[1] = CMdaAudioToneUtility::NewL(*callback[1],NULL,  0, EMdaPriorityPreferenceTimeAndQuality);
	CleanupStack::PushL(toneUtil[1]);

	toneUtil[0]->PrepareToPlayDTMFString(KDTMFString);
	toneUtil[1]->PrepareToPlayDTMFString(KDTMFString);
	
	// wait for initilisation callback
	iCallbackCount = 2;
	INFO_PRINTF1( _L("Initialise CMdaAudioToneUtility"));
	INFO_PRINTF1( _L("Initialise CMdaAudioToneUtility"));
	CActiveScheduler::Start();

	if(iError == KErrNone)
		{
		iError = KErrTimedOut;

		toneUtil[0]->Play();
		toneUtil[1]->Play();

		INFO_PRINTF1( _L("Play CMdaAudioToneUtility"));
		INFO_PRINTF1( _L("Play CMdaAudioToneUtility"));

		// wait for play to complete
		iCallbackCount = 2;
		iFirstCallback = -1;
		CActiveScheduler::Start();

		if((iError == KErrNone) && (iFirstCallback == 0))
			{
			CleanupStack::PopAndDestroy(4);
			return	EPass;
			}
		}

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

	CleanupStack::PopAndDestroy(4);
	return	EFail ;
	}

//------------------------------------------------------------------

/**
 * Constructor
 */
CTestMmfAclntToneBalance::CTestMmfAclntToneBalance(const TDesC& aTestName,const TInt aBalance)
	:CTestMmfAclntTone(aTestName) ,iBalance(aBalance)
	{}

CTestMmfAclntToneBalance* CTestMmfAclntToneBalance::NewL(const TDesC& aTestName,const TInt aBalance)
	{
	CTestMmfAclntToneBalance* self = new (ELeave) CTestMmfAclntToneBalance(aTestName,aBalance);
	return self;
	}

/**
 * Set balance and enquire balance
 */
TVerdict CTestMmfAclntToneBalance::DoTestL(CMdaAudioToneUtility* aToneUtil)
	{
	INFO_PRINTF1( _L("TestTone : Balance"));

	if (iBalance < KMinBalance)
		{
		TRAPD(err, aToneUtil->SetBalanceL(iBalance));

		if (err != KErrNone)
		{
			INFO_PRINTF2(_L("SetBalanceL() returned unexpected error %d"), err);
			return EFail;
		}

		if(aToneUtil->GetBalanceL() == KMinBalance)
			return EPass;
		}
	else if (iBalance > KMaxBalance)
		{
		TRAPD(err, aToneUtil->SetBalanceL(iBalance));

		if (err != KErrNone)
		{
			INFO_PRINTF2(_L("SetBalanceL() returned unexpected error %d"), err);
			return EFail;
		}

		if(aToneUtil->GetBalanceL() == KMaxBalance)
			return EPass;
		}
	else 
		{
		TRAPD(err, aToneUtil->SetBalanceL(iBalance));

		if (err != KErrNone)
		{
			INFO_PRINTF2(_L("SetBalanceL() returned unexpected error %d"), err);
			return EFail;
		}

		if(aToneUtil->GetBalanceL() == iBalance)
			return EPass;
		}

	return EFail;
	}

//------------------------------------------------------------------

// NEGATIVE TESTING

//------------------------------------------------------------------



/**
 * Constructor
 */
CTestMmfAclntOnOffPause::CTestMmfAclntOnOffPause()
	{
	// 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 = _L("MM-MMF-ACLNT-I-1155-HP");

// this test does not inherit from CTestMmfAclntTone
// so we need to make the heap bigger here	
// need a bigger heap size on EKA2 HW
#if !defined __WINS__	
	iHeapSize = KHeapSizeToneTestEKA2;
#endif // EKA2
	}

void CTestMmfAclntOnOffPause::MatoPrepareComplete(TInt aError)
	{
	iError = aError;
	INFO_PRINTF1( _L("CTestMmfAclntOnOffPause::MatoPrepareComplete MMdaAudioToneObserver Callback for CMdaAudioToneUtility complete"));
	INFO_PRINTF2( _L("iError %d"), iError);
	CActiveScheduler::Stop();
	}

void CTestMmfAclntOnOffPause::MatoPlayComplete(TInt aError)
	{
	iError = aError;
	INFO_PRINTF1( _L("CTestMmfAclntOnOffPause::MatoPlayComplete MMdaAudioToneObserver Callback for CMdaAudioToneUtility complete"));
	INFO_PRINTF2( _L("iError %d"), iError);
	CActiveScheduler::Stop();
	}

/**
 * Set up tone on, off and pause length to illegal values.
 */
TVerdict CTestMmfAclntOnOffPause::DoTestStepL( void )
	{
	INFO_PRINTF1( _L("TestTone : On/Off/Pause"));
	TVerdict res = EFail;

	iError = KErrTimedOut;

	CMdaAudioToneUtility* toneUtil = CMdaAudioToneUtility::NewL(*this);
	CleanupStack::PushL(toneUtil);
	toneUtil->PrepareToPlayDTMFString(KDTMFString);
	// Wait for prepare
	INFO_PRINTF1( _L("Initialise CMdaAudioToneUtility"));
	CActiveScheduler::Start();

	if(iError == KErrNone)
		{
		iError = KErrTimedOut;

		TTimeIntervalMicroSeconds32 on(-4), off(-3), pause(-5);
		
		toneUtil->SetDTMFLengths(on, off, pause);

		toneUtil->Play();
		// wait for play to complete
		INFO_PRINTF1( _L("Play CMdaAudioToneUtility"));
		CActiveScheduler::Start();

		// check this worked
		if(iError == KErrNone)
			res = EPass;
		}

	CleanupStack::Pop(); // toneUtil
	ERR_PRINTF2( _L("CMdaAudioToneUtility completed with error %d"),iError );
	delete toneUtil;
	return	res;
	}