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

 //

 #include <mmf/server/mmffile.h>

 #include "CustomMmfAudioController.h"

 #include <mmf/plugin/mmfcontrollerimplementationuids.hrh>

 #include "ActrlTestUids.h"

 _LIT(KTestWavFile19, "c:\\mm\\mmf\\testfiles\\actrl\\newmail.wav");

 /**

 *

 * NewL

 *

 */

 CMMFController* CCustomMmfAudioController::NewL()

 	{

     CCustomMmfAudioController* self = new(ELeave) CCustomMmfAudioController;

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop( self );

 	return STATIC_CAST( CMMFController*, self );

 	}

 /**

 *

 * ~CCustomMmfAudioController

 *

 */

 CCustomMmfAudioController::~CCustomMmfAudioController()

 	{

     delete iStoppingMessage;

 	}

 /**

 *

 * CCustomMmfAudioController

 *

 */

 CCustomMmfAudioController::CCustomMmfAudioController()

 :CMMFAudioController(), iIsTest(EFalse)

 	{

 	}

 /**

  *  PrimeL

  *

  *  If Prime fails the client should reset the controller

  *  becaused as noted below this code is not transactional.

  *

  */

 void CCustomMmfAudioController::PrimeL(TMMFMessage& aMessage)

 	{

 	PrimeL();

 	aMessage.Complete(KErrNone);

 	}

 void CCustomMmfAudioController::PlayL(TMMFMessage& aMessage)

 	{

 	PlayL();

 	aMessage.Complete(KErrNone);

 	}

 void CCustomMmfAudioController::PauseL(TMMFMessage& aMessage)

 	{

 	PauseL();

 	aMessage.Complete(KErrNone);

 	} 

 void CCustomMmfAudioController::PrimeL()

 	{

 	// apply heap check's here

 	// Note if they fail this is the end of the controller

 	// call the base class functionality

 	TRAPD( errorCode, CMMFAudioController::PrimeL());

 	// send an event back to the test framework with 

 	// the error code

 	TMMFEvent aEvent( KPrimeTestId, errorCode );

 	DoSendEventToClient(aEvent);

 	//[ we need to preserve the leave semantics for the caller]

 	User::LeaveIfError( errorCode );

 	}

 /**

  *

  *  PlayL

  *

  */

 void CCustomMmfAudioController::PlayL()

 	{

 // call the base class functionality

 	TRAPD( errorCode, CMMFAudioController::PlayL());

 	// send an event back to the test framework with 

 	// the error code

 	TMMFEvent aEvent( KPlayTestId, errorCode );

 	DoSendEventToClient(aEvent);

 	//[ we need to preserve the leave semantics for the caller]

 	User::LeaveIfError( errorCode );

 	}

 /**

 *

 * MapdSetVolumeL

 *

 */

 void CCustomMmfAudioController::MapdSetVolumeL(TInt aVolume)

 	{

 	//Special return code to test fix for PDEF120609, test case id MM-MMF-ACLNT-U-0277-CP

 	if (aVolume == -999)

 		{

 		User::Leave(-12345);

 		}

 	CMMFAudioController::MapdSetVolumeL( aVolume );

 	}

 /**

 *

 * MapdGetMaxVolumeL

 *

 */

 void CCustomMmfAudioController::MapdGetMaxVolumeL(TInt& aMaxVolume)

 	{

 	CMMFAudioController::MapdGetMaxVolumeL( aMaxVolume );

 	}

 /**

 * MapdGetVolumeL

 *

 */

 void CCustomMmfAudioController::MapdGetVolumeL(TInt& aVolume)

 	{

 	CMMFAudioController::MapdGetVolumeL( aVolume );

 	}

 /**

 * 

 *PauseL

 *

 */

 void CCustomMmfAudioController::PauseL()

 	{

 	TRAPD( errorCode,CMMFAudioController::PauseL());

 	//[ send pause event ]

 	TMMFEvent aEvent( KPauseTestId, errorCode );

 	DoSendEventToClient(aEvent);

 	//[ we need to preserve the leave semantics for the caller]

 	User::LeaveIfError( errorCode );

 	}

 /**

 * 

 * StopL

 *

 */

 void CCustomMmfAudioController::StopL()

 	{

 	TRAPD( errorCode,CMMFAudioController::StopL());

 	//[ send stop event ]

 	TMMFEvent aEvent( KStopTestId, errorCode );

 	DoSendEventToClient(aEvent);

 	//[ we need to preserve the leave semantics for the caller]

 	User::LeaveIfError( errorCode );

 	}

 /**

 *

 * ResetL

 *

 */

 void CCustomMmfAudioController::ResetL()

 	{

 	TRAPD( errorCode,CMMFAudioController::ResetL());

 	//[ send stop event ]

 	TMMFEvent aEvent( KResetTestId, errorCode );

 	DoSendEventToClient(aEvent);

 	//[ we need to preserve the leave semantics for the caller]

 	User::LeaveIfError( errorCode );

 	}

 /**

 *

 * RemoveDataSourceL

 *

 */

 void CCustomMmfAudioController::RemoveDataSourceL(MDataSource& aDataSource)

 	{

 	TRAPD( errorCode,CMMFAudioController::RemoveDataSourceL( aDataSource));

 	//[ send stop event ]

 	TMMFEvent aEvent( KRemoveDataSourceTestId, errorCode );

 	DoSendEventToClient(aEvent);

 	//[ we need to preserve the leave semantics for the caller]

 	User::LeaveIfError( errorCode );

 	}

 /**

 *

 * RemoveDataSinkL

 *

 */

 void CCustomMmfAudioController::RemoveDataSinkL(MDataSink& aDataSink)

 	{

 	TRAPD( errorCode,CMMFAudioController::RemoveDataSinkL( aDataSink));

 	//[ send stop event ]

 	TMMFEvent aEvent( KRemoveDataSinkTestId, errorCode );

 	DoSendEventToClient(aEvent);

 	//[ we need to preserve the leave semantics for the caller]

 	User::LeaveIfError( errorCode );

 	}

 /**

 *

 * MarcSetMaxFileSizeL

 *

 */

 void CCustomMmfAudioController::MarcSetMaxFileSizeL(TInt aFileSize)

 	{

 	TRAPD( errorCode,CMMFAudioController::MarcSetMaxFileSizeL( aFileSize));

 	//[ send stop event ]

 	TMMFEvent aEvent( KMarcSetMaxFileSizeId, errorCode );

 	DoSendEventToClient(aEvent);

 	//[ we need to preserve the leave semantics for the caller]

 	User::LeaveIfError( errorCode );

 	}

 /**

 *

 * MarcGetRecordTimeAvailableL

 * @param aTime

 *

 */

 void CCustomMmfAudioController::MarcGetRecordTimeAvailableL(TTimeIntervalMicroSeconds& aTime)

 	{

 	TRAPD( errorCode,CMMFAudioController::MarcGetRecordTimeAvailableL( aTime));

 	//[ send stop event ]

 	TMMFEvent aEvent( KMarcGetRecordTimeAvailId, errorCode );

 	DoSendEventToClient(aEvent);

 	//[ we need to preserve the leave semantics for the caller]

 	User::LeaveIfError( errorCode );

 	}

 /**

 *

 * CustomCommand

 *

 */

 void CCustomMmfAudioController::CustomCommand(TMMFMessage& aMessage)

 	{

 	//[ check if the command is for the custom plugin

 	// otherwise pass it on to the real audio controller ]

 	TRAPD(err, iStoppingMessage = CCustomMMFMessageHolder::NewL(aMessage));

 	if (err != KErrNone)

 		{

 		aMessage.Complete(err);

 		return;

 		}

 	iIsTest = ETrue;

 	if( IsMemoryAllocCmd( aMessage ) )

 		{

 		//[ it is a alloc memory test command ]

 		// [ new algorithm adopted from M&G database ]

 		//

 		TInt errorCode = KErrNone;

 		TInt failCount  = 1;

 		TBool completed  = EFalse;

 		TBool badResult  = EFalse;

 		TBool reachedEnd = EFalse; 

 		for( ; ; )

 			{

 			__UHEAP_SETFAIL(RHeap::EFailNext ,failCount);	// Leavescan will think __UHEAP_SETFAIL is a leaving function due to the macro ending in 'L'. Does not leave

 			//NB: Do not use __MM_HEAP_MARK macro's in this test, the cleaning up the CustomMMFAudioController

 			//is insufficient to remove all possible allocated memory from the framework.

 			//CMMFControllerProxyServer::DoStartThreadL has been updated to do heap checking for 

 			//the whole server thread.

 			//[ run a scenario of the major api 

 			//functions which alloc memory in the controller]

 			TRAP( errorCode, AllocMemoryTestL());

 			if( errorCode == KErrNone )

 				{

 				// [ check we have passed through all allocs in the test]

 				TAny* testAlloc = User::Alloc(1);

 				if( testAlloc == NULL )

 					{

 					reachedEnd = ETrue;

 					failCount -= 1; // Failcount of 1 equates to 0 successful allocs, etc.

 					}

 				else 

 					{

 					User::Free( testAlloc );

 					}

 				completed = reachedEnd || badResult;

 				}

 			else if( errorCode != KErrNoMemory ) 

 				{

 				// [ we failed for some reason other than memory

 				//     allocation, so fail the test ]

 				completed = ETrue;

 				badResult = ETrue;

 				}

 			__UHEAP_SETFAIL(RHeap::ENone ,0);

 			// [ exit the loop ]

 			if( completed )

 				{

 				break;

 				}

 			failCount +=1;

 			}

 		//This flag is used by the audio controller to alter its behaviour

 		//slightly to allow these tests to work

 		iIsTest=EFalse;

 		if(!badResult)

 			{

 			aMessage.Complete(KErrNone);

 			}

 		else

 			{

 			aMessage.Complete(errorCode);

 			}

 		}

 	else

 		{

 		//[ let the plugin process the message ]

 		CMMFAudioController::CustomCommand(aMessage);

 		}

 	}

 /**

 *

 * IsMemoryAllocCmd

 *

 */

 TBool CCustomMmfAudioController::IsMemoryAllocCmd( TMMFMessage& )

 	{

 	return ETrue;

 	}

 static void CleanupController(TAny* ptr)

 	{

 	CMMFAudioController* controller = STATIC_CAST(CMMFAudioController*, ptr);

 	TRAP_IGNORE(controller->CMMFAudioController::ResetL());

 	}

 /**

 *

 * AllocMemoryTest

 *

 */

 TInt CCustomMmfAudioController::AllocMemoryTestL()

 	{

 	TMMFFileConfig fileConfig; // audio file 

 	fileConfig().iPath = KTestWavFile19;

 	//[ lets manufacture a source and sink ]

 	//[Create the source]

 	MDataSource* source = MDataSource::NewSourceL(KUidMmfFileSource, fileConfig);

 	CleanupDeletePushL(source);

 	//[ Create the sink ]

 	MDataSink* sink = MDataSink::NewSinkL(KUidMmfAudioOutput, KNullDesC8);

 	CleanupDeletePushL(sink);

 	// Use a cleanup item to stop & reset the controller and so remove the data 

 	// sources/sinks automatically when this funtion leaves. This can be done

 	// before the sinks/sources are added.

 	TCleanupItem cleanupItem(CleanupController, this);

 	CleanupStack::PushL(cleanupItem);

 	//[ add the source ]

 	CMMFAudioController::AddDataSourceL(*source);

 	//[ add the sink ]

 	CMMFAudioController::AddDataSinkL(*sink);

 	//[ prime ]

 	CMMFAudioController::PrimeL();	 

 	//[ play ]

 	CMMFAudioController::PlayL();

 	//[ pause ]

 	CMMFAudioController::PauseL();

 	//[ play ]

 	CMMFAudioController::PlayL();

 	//[ stop ]

 	CMMFAudioController::StopL(iStoppingMessage->iMessage);

 	// [ prime ]

 	CMMFAudioController::PrimeL();

 	//[ reset ]	

 	CMMFAudioController::ResetL();

 	CleanupStack::PopAndDestroy(3);// source, sink, cleanupItem

 	return KErrNone;

 	}

 //Leaves with KErrNoMemory.

 CMMFController* CMemoryFailAudioController::NewL()

 	{

 	if(ETrue) //condition used to avoid any warning

 		{

 		User::Leave(KErrNoMemory);	

 		}

 	return NULL;

 	}

 CMemoryFailAudioController::CMemoryFailAudioController():CMMFAudioController()

 	{

 	}

 CMemoryFailAudioController::~CMemoryFailAudioController()

 	{

     if(iSink)

     	{

     	iSink->SinkThreadLogoff();

     	}

     if(iClip)

     	{

     	iClip->SourceThreadLogoff();

     	}

 	}

 void CMemoryFailAudioController::AddDataSourceL(MDataSource& aSource)

 	{

     if (iClip)

     	{

     	User::Leave(KErrAlreadyExists);

     	}

 	if ((aSource.DataSourceType()==KUidMmfDescriptorSource)||

 			(aSource.DataSourceType()==KUidMmfFileSource))

 	    {

 	    User::LeaveIfError(aSource.SourceThreadLogon(*this));

 	    iClip = static_cast<CMMFClip*>(&aSource);

 	    if(iClip->Size())

 	    	{

 	    	iClip->SourcePrimeL();

 	    	}

 	    else

 	    	{

 	    	iClip->SourceStopL();

 	    	}

 	    }

 	else 

 		{

 		User::Leave(KErrNotSupported);

 		}

 	}

 void CMemoryFailAudioController::AddDataSinkL(MDataSink& aSink)

 	{

     if(iMMFDevSound)

     	{

     	User::Leave(KErrAlreadyExists);

     	}

     if (aSink.DataSinkType()!=KUidMmfAudioOutput) 

     	{

     	User::Leave(KErrNotSupported);	

     	}

     User::LeaveIfError(aSink.SinkThreadLogon(*this));

     iSink = &aSink;

     MMMFAudioOutput* audioOutput = static_cast<MMMFAudioOutput*>(&aSink);

     iMMFDevSound = &(audioOutput->SoundDevice());

 	iMMFDevSound->SetPrioritySettings(iPrioritySettings);

 	return;

 	}

 void CMemoryFailAudioController::SetPrioritySettings(const TMMFPrioritySettings& aSettings)

 	{

     iPrioritySettings = aSettings;

     if (iMMFDevSound)

     	{

     	iMMFDevSound->SetPrioritySettings(aSettings);

     	}

 	}

 //Does not acces files; returns hard-coded value.

 TTimeIntervalMicroSeconds CMemoryFailAudioController::DurationL()const

 	{

 	return TTimeIntervalMicroSeconds(1000000); //return 1sec

 	}

 CMMFController* CMemoryPassAudioController::NewL()

 	{

 	CMemoryPassAudioController* self = new (ELeave) CMemoryPassAudioController();

 	return STATIC_CAST( CMMFController*, self );

 	}

 CMemoryPassAudioController::CMemoryPassAudioController():CMemoryFailAudioController()

 	{

 	}

 //Derived from Audio Controller. Panics the controller thread after the play is started

 CMMFController* CPanicAudioController::NewL()

 	{

 	CPanicAudioController* self = new(ELeave) CPanicAudioController;

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop( self );

 	return static_cast<CMMFController*>(self);

 	}

 CPanicAudioController::CPanicAudioController():CMMFAudioController()

 	{

 	}

 CPanicAudioController::~CPanicAudioController()

 	{

 	delete iPanicTimer;

 	}

 void CPanicAudioController::AddDataSourceL(MDataSource& aSource)

 	{

     TRAP_IGNORE(CMMFAudioController::AddDataSourceL(aSource));

 	}

 void CPanicAudioController::AddDataSinkL(MDataSink& aSink)

 	{

     TRAP_IGNORE(CMMFAudioController::AddDataSinkL(aSink));

 	}

 void CPanicAudioController::PrimeL()

 	{

 	TRAP_IGNORE(CMMFAudioController::PrimeL());

 	}

 void CPanicAudioController::PlayL()

 	{

 	TRAP_IGNORE(CMMFAudioController::PlayL());

 	//trigger the panic

 	iPanicTimer->Start(1000000, 1000000, TCallBack(PanicTimerComplete, this));

 	}

 void CPanicAudioController::ConstructL()

 	{

 	CMMFAudioController::ConstructL();

 	iPanicTimer = CPeriodic::NewL(CActive::EPriorityStandard);

 	}

 TTimeIntervalMicroSeconds CPanicAudioController::DurationL()const

 	{

 	return TTimeIntervalMicroSeconds(0);

 	}

 void CPanicAudioController::SetPositionL(const TTimeIntervalMicroSeconds& aPosition)

 	{

 	TRAP_IGNORE(CMMFAudioController::SetPositionL(aPosition));

 	}

 TInt CPanicAudioController::PanicTimerComplete(TAny* /*aParent*/)

 	{

 	User::Panic(_L("CustomMmfAudioController"), 0);

 	return KErrNone;

 	}