// 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);