// 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:

// These test steps create audio player utilities whose

// controllers share a single heap.

// 

//

// EPOC includes

#include <e32base.h>

#include <e32test.h>

#include <e32keys.h>

#include <c32comm.h>

#include <f32file.h>

#include <etel.h>

#include <etelmm.h>

#include <testframework.h>

#include <mdaaudiosampleplayer.h>

// Test system includes

#include <testframework.h>

// Specific includes for this test suite

#include "TestStepUnitMMFAudClient.h"

// Specific includes for these test steps

#include "TestStepPlayerSharedHeap.h"

#include "mmfclientaudioplayer.h"

// For custom controller

#include "../../ctlfrm/TS_CMMFTestController/CmmfTestControllerUIDs.hrh"

#include "../../ctlfrm/TS_Codes.h"

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

const TInt KMaxPlayers = 24;

// would definitely exceed the chunk limit if there players were

// using separate heaps (which they shouldn't in this test)

const TInt KNoSharedPlayer = 2;

// which of the created players should be given its own heap on mixed style tests

// This must always be true: KNoSharedPlayer < KMaxPlayers

const TInt KRepeatAmount = 16;

// how often CTestStepPlayerSharedHeapRepeatMultiFilePlayer should create and delete players

const TUid KTstControllerUid = {KMmfTestControllerUid}; //(0x101F88D8)

// custom controller ID

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

/**

 *

 * Static constructor for CTestStepPlayerSharedHeapMultiFilePlayer.

 *

 *

 * @return	"CTestStepPlayerSharedHeapMultiFilePlayer*"

 *			The constructed CTestStepPlayerSharedHeapMultiFilePlayer

 *

 * @xxxx

 * 

 */

CTestStepPlayerSharedHeapMultiFilePlayer* CTestStepPlayerSharedHeapMultiFilePlayer::NewL(const TDesC& aName, TBool aMixHeapStyle )

	{

	CTestStepPlayerSharedHeapMultiFilePlayer* self = new(ELeave) CTestStepPlayerSharedHeapMultiFilePlayer( aName, aMixHeapStyle );

	return self;

	}

/**

 *

 * Test step constructor.

 * Each test step initialises its own name.

 *

 * @xxxx

 * 

 */

CTestStepPlayerSharedHeapMultiFilePlayer::CTestStepPlayerSharedHeapMultiFilePlayer(const TDesC& aName, TBool aMixHeapStyle )

	: iMixHeapStyle( aMixHeapStyle )

	{

	// store the name of this test case

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

	iTestStepName = aName;

	iHeapSize = 128 * 1024; 

	}

/**

 *

 * Test step destructor.

 *

 * @xxxx

 * 

 */

CTestStepPlayerSharedHeapMultiFilePlayer::~CTestStepPlayerSharedHeapMultiFilePlayer()

	{

	}

/**

 * Implementation of the MMdaAudioPlayerCallback interface functions

 **/

void CTestStepPlayerSharedHeapMultiFilePlayer::MapcInitComplete(TInt aError, 

															const TTimeIntervalMicroSeconds &/*aDuration*/)

	{

	iError = aError;

	if( aError )

		{

		INFO_PRINTF2(_L("	Callback error (%d) while opening player."), aError);

		}

	/*else

		{

		INFO_PRINTF1(_L("	Player opened successfully."));

		}*/

	CActiveScheduler::Stop();

	}

void CTestStepPlayerSharedHeapMultiFilePlayer::MapcPlayComplete(TInt aError)

	{

	iError = aError;

	CActiveScheduler::Stop();

	}

/**

 *

 * Test step Preamble.

 *

 * @xxxx

 * 

 */

enum TVerdict CTestStepPlayerSharedHeapMultiFilePlayer::DoTestStepPreambleL(void)

	{

	 enum TVerdict verdict;

	 // this installs the scheduler

	 verdict = CTestStepUnitMMFAudClient::DoTestStepPreambleL();

	// Printing to the console and log file

	INFO_PRINTF1( iTestStepName );

	iError = KErrNone; //KErrTimedOut;

	if(!GetStringFromConfig(_L("SectionOne"), _L("AudioPlayFName1"), iFileName))

		{

		return EInconclusive;

		}

	return verdict;

	}

/**

 *

 * Test step Postamble.

 *

 * @xxxx

 * 

 */

enum TVerdict CTestStepPlayerSharedHeapMultiFilePlayer::DoTestStepPostambleL(void)

	{

	// close array

	iPlayers.Close();

	INFO_PRINTF1(_L("finished with this test step"));

	//[ Destroy the scheduler ]

	return CTestStepUnitMMFAudClient::DoTestStepPostambleL();

	}

/**

 *

 * The commands to be included in the TRAP command

 *

 * @xxxx

 * 

 */

CMdaAudioPlayerUtility* CTestStepPlayerSharedHeapMultiFilePlayer::CreateAndOpenPlayerL( TInt aIteration )

	{

	CMdaAudioPlayerUtility* player = NULL;

	TRAPD( err, player = CMdaAudioPlayerUtility::NewL(*this) );

	User::LeaveIfError( err );

	CleanupStack::PushL(player);

	if( ! (iMixHeapStyle && (aIteration == KNoSharedPlayer)) )

		{

		INFO_PRINTF2(_L("	Player on iteration %2d is using a shared heap."), aIteration );

		player->UseSharedHeap(); // ensure that underlying controller uses a shared heap

		}

	else

		{

		INFO_PRINTF2(_L("	Player on iteration %2d has its own heap."), aIteration );

		}

	player->OpenFileL( iFileName ); // this creates a new controller

	CActiveScheduler::Start(); // wait for open to complete

	User::LeaveIfError( iError ); // if had error return from callback

	CleanupStack::Pop(player);

	return player;

	}

/**

 *

 * Get's the Audio Player State

 *

 * @xxxx

 * 

 */

TInt CTestStepPlayerSharedHeapMultiFilePlayer::GetAudPlayerState(CMdaAudioPlayerUtility* aPlayer, TInt& aState)

	{

	if (aPlayer == NULL)

		return KErrNotReady;

	aState = this->iState;

	return KErrNone;

	}

/**

 *

 * Get's the Audio Player Source Handle

 *

 * @xxxx

 * 

 */

TInt CTestStepPlayerSharedHeapMultiFilePlayer::GetAudPlayerSourceHandle(CMdaAudioPlayerUtility* aPlayer,

														 TMMFMessageDestination* /*aSrcHandle*/)

	{

	if (aPlayer == NULL)

		return KErrNotReady;

	return KErrNone;

	}

/**

 *

 * Creates KMaxPlayers players, performs the desired test on one of them

 * and then closes them all and cleans up.

 * If problems are encountered the returned result will reflect this.

 *

 * @return	"TVerdict"

 *			The result of the tests

 *

 * @xxxx

 * 

 */

TVerdict CTestStepPlayerSharedHeapMultiFilePlayer::DoTestL( TTestType aTestType )

	{

	iTestStepResult = EPass;

    TInt err = KErrNone;

	__MM_HEAP_MARK;

	TInt i=0;

	for( ; i < KMaxPlayers; ++i )	

		{

		iError = KErrNone;

		CMdaAudioPlayerUtility* player = NULL;

		TRAPD(err, player = CreateAndOpenPlayerL(i) );

		if (err == KErrNone && iError == KErrNone)

			{

			// see if valid result and break if wrong - might be premature result

			TInt err1 = KErrNone;

			TInt err2 = KErrNone;

			TInt state = 0;

			TMMFMessageDestination* srcHandle = NULL;

			err1 = GetAudPlayerState(player, state);

			err2 = GetAudPlayerSourceHandle(player, srcHandle);

			if ( err1 != KErrNone ||

				 err2 != KErrNone ||

				 &srcHandle == NULL ||

				 state != CTestStepPlayerSharedHeapMultiFilePlayer::EStopped ||

				 player->Duration() == TTimeIntervalMicroSeconds(0) || // we know the duration of the file is more than 0

				 iError != KErrNone)

				{

				// dodgy player

				INFO_PRINTF2(_L("	Dodgy player on iteration %2d"), i);

				iTestStepResult = EFail;

				delete player;

				player = NULL;

				break;

				}

			else

				{

				// no errors				

				// append player to array

				if( (err = iPlayers.Append( player )) != KErrNone )

					{

					INFO_PRINTF2(_L("Fail to append player on iteration %2d"), i);

					// this doesn't indicate a failure in what we're testing here

					iTestStepResult = EInconclusive;

					delete player;

					player = NULL;

					break;

					}

				}

			}

		else

			{

			INFO_PRINTF4(_L("Fail to open player on iteration %2d - %d %d"), i, err, iError);

			break;

			}	

		}

	// check outcome of making players

	if ( err || iError )

		{

		if ((err && err != KErrNoMemory) || (err == KErrNone && iError != KErrNoMemory))

			{

			// a genuine error

			if( err )

				{

				INFO_PRINTF3(_L("Error %d occured while trying to create player #%d"), err, i );

				}

			else

				{

				INFO_PRINTF3(_L("Error %d occured while opening player #%d"), iError, i );

				}

			iTestStepResult = EFail;

			}

		else

			{

			// we ran out of memory

			INFO_PRINTF2(_L("Teststep ran out of memory while creating player #%d"), i );

			iTestStepResult = EFail;

			}

		}

	// else no errors

	// perform test on 1st player (unless there were errors above)

	if( (iTestStepResult == EPass) && (iPlayers.Count() > 0 ) )

		{

		switch( aTestType )

			{

			case EPlay:

				{		

				(iPlayers[0])->Play();

				CActiveScheduler::Start();

				if( iError )

					{

					// playback died

					INFO_PRINTF2(_L("Error %d occured while playing"), iError );

					iTestStepResult = EFail;

					}

				break;

				}

			case EPanic:

				{

				// panic player

				// load a custom controller (using the share heap)

				// that can be panicked and see if we recover OK

				TMMFPrioritySettings settings;

				TInt error = KErrNone;

				RMMFController controller;

				settings.iPriority = 1;

				settings.iPref = EMdaPriorityPreferenceTime;

				settings.iState = EMMFStateIdle;

				error = controller.Open(KTstControllerUid, settings, ETrue); // use shared heap

				INFO_PRINTF2(_L("Custom controller Open: %d"), error);

				if( ! error )

					{

					// panic the controller

					// this command will complete immediately and

					// then panic

					TUid uid;

					uid = TUid::Uid(0x101f72B4);

					TMMFMessageDestinationPckg destPckg(uid);

					//TRequestStatus status = KRequestPending;

					controller.CustomCommandSync(destPckg,

												EMMFTestCustomCommandPanic,

												KNullDesC8,

												KNullDesC8);

					// need to allow some time to make

					// sure the thread has actually been panicked when we close it

					User::After( TTimeIntervalMicroSeconds32(5000000) ); // 5 seconds

					}

				// controller should have panicked by now

				controller.Close();

				break;

				}

			// default: // do nothing

			}

		}

	// cleanup

	for( i = 0; i < iPlayers.Count(); ++i )

		{

		delete iPlayers[i];

		iPlayers[i] = NULL;

		}

	iPlayers.Reset();

	__MM_HEAP_MARKEND;

	// test steps return a result

	return iTestStepResult;

	}

/**

 *

 * Do the test step.

 * Each test step must supply an implementation for DoTestStepL.

 *

 * @return	"TVerdict"

 *			The result of the test step

 *

 * @xxxx

 * 

 */

TVerdict CTestStepPlayerSharedHeapMultiFilePlayer::DoTestStepL()

	{

	INFO_PRINTF1(_L("This is a test that several player utilities using a shared heap can be created."));

	return DoTestL( EPlay );

	}

//===========================================================================================

/**

 *

 * Static constructor for CTestStepPlayerSharedHeapRepeatMultiFilePlayer.

 *

 *

 * @return	"CTestStepPlayerSharedHeapRepeatMultiFilePlayer*"

 *			The constructed CTestStepPlayerSharedHeapRepeatMultiFilePlayer

 *

 * @xxxx

 * 

 */

CTestStepPlayerSharedHeapRepeatMultiFilePlayer* CTestStepPlayerSharedHeapRepeatMultiFilePlayer::NewL(const TDesC& aName, TBool aMixHeapStyle )

	{

	CTestStepPlayerSharedHeapRepeatMultiFilePlayer* self = new(ELeave) CTestStepPlayerSharedHeapRepeatMultiFilePlayer( aName, aMixHeapStyle );

	return self;

	}

/**

 *

 * Test step constructor.

 * Each test step initialises its own name.

 *

 * @xxxx

 * 

 */

CTestStepPlayerSharedHeapRepeatMultiFilePlayer::CTestStepPlayerSharedHeapRepeatMultiFilePlayer(const TDesC& aName, TBool aMixHeapStyle )

	: CTestStepPlayerSharedHeapMultiFilePlayer( aName, aMixHeapStyle )

	{

	}

/**

 *

 * Test step destructor.

 *

 * @xxxx

 * 

 */

CTestStepPlayerSharedHeapRepeatMultiFilePlayer::~CTestStepPlayerSharedHeapRepeatMultiFilePlayer()

	{

	}

/**

 *

 * Do the test step.

 * Each test step must supply an implementation for DoTestStepL.

 *

 * @return	"TVerdict"

 *			The result of the test step

 *

 * @xxxx

 * 

 */

TVerdict CTestStepPlayerSharedHeapRepeatMultiFilePlayer::DoTestStepL()

	{

	INFO_PRINTF1(_L("This is a test that several player utilities using a shared heap can be created."));

	TVerdict result = EPass;

	__MM_HEAP_MARK;

	for(TInt i=0; i < KRepeatAmount; ++i)

		{

		INFO_PRINTF2(_L("Create and delete iteration %d."), i );

		result = DoTestL( EPlay );

		if( result != EPass )

			{

			INFO_PRINTF2(_L("Iteration %d failed. Stopping."), i );

			break;

			}