// Copyright (c) 2003-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/mmfformat.h>

#include <mmf/server/mmfclip.h>

#include <mdaaudiosampleeditor.h>

#include <mmfcontrollerimplementationuids.hrh>

#include <mmf/common/mmffourcc.h>

#include <mmf/common/mmfpaniccodes.h>

#include "MmfAudioToneController.h"

#include <mmf/server/mmfaudiooutput.h>

/*

 A list of panic codes for the Audio Tone Controller

@internalTechnology

 TMmfAudioToneControllerPanics is an enumeration with the following entries:

 EBadArgument indicates a bad argument

 EBadState indicates a state viaolation

 EBadInvariant indicates an invariant violation

 EBadReset indicates failed reset

 EPostConditionViolation indicates a post condition violation

*/

enum TMmfAudioToneControllerPanics

	{

	EBadArgument,

	EBadState,

	EBadInvariant,

	EBadReset,

	EPostConditionViolation,

	EBadCall,

	ENoDataSource,

	ENoDataSink,

	EMessageAlreadyBeingProcessed,

	ENoMessageToProcess,

	EStateNotReadyToPlay,

	EStateNotConstructed,

	EBadStateToGetDataSource,

	EBadStateToGetDataSink,

	EBadStateForPrime,

	EStateNotPrimed,

	EBadResetState,

	EBadStateToReset,

	EBadPlayState,

	EBadPauseState,

	EBadStateToPause,

	EBadStateToStop,

	EBadStopState,

	ENotReadyForDataSourceRemoval,

	EBadDataSourceRemoval,

	ENotReadyForDataSinkRemoval,

	EBadDataSinkRemoval,

	ENotReadyForCustomCommand,

	EBadStateAfterNegotiate,

	EBadStateToSetPriority,

	EBadPriorityState,

	EBadInitializeState,

	EBadStateToSetVolume,

	EBadStateAfterVolumeSet,

	EBadStateToGetMaxVolume,

	EBadStateAfterGetMaxVolume,

	EBadStateToGetVolume,

	EBadStateAfterGetVolume,

	EBadStateToSetVolumeRamp,

	EBadStateAfterSetVolumeRamp,

	EBadStateToSetBalance,

	EBadStateAfterSetBalance,

	EBadStateToGetBalance,

	EBadStateAfterGetBalance,

	EBadStateForTransition,

	EBadStateAfterTransition,

	EStateNotValid,

	};

/**

 Instantiates a new Audio Tone Controller. Usually invoked from ECom

 @internalTechnology

 @return CMMFController* bas class for all plugin controllers

 */

CMMFController* CMMFAudioToneController::NewL()

	{

	CMMFAudioToneController* self = new(ELeave) CMMFAudioToneController;

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop( self );

	return STATIC_CAST( CMMFController*, self );

	}

/**

2nd Phase constructor

@internalComponent

*/

void CMMFAudioToneController::ConstructL()

	{

	iSourceAndSinkAdded = EFalse;

	// Construct custom command parsers

	CMMFAudioPlayDeviceCustomCommandParser* audPlayDevParser = CMMFAudioPlayDeviceCustomCommandParser::NewL(*this);

	CleanupStack::PushL(audPlayDevParser);

	AddCustomCommandParserL(*audPlayDevParser);

	CleanupStack::Pop( audPlayDevParser );//audPlayDevParser

	CMMFAudioPlayControllerCustomCommandParser* audPlayConParser = CMMFAudioPlayControllerCustomCommandParser::NewL(*this);

	CleanupStack::PushL(audPlayConParser);

	AddCustomCommandParserL(*audPlayConParser);

	CleanupStack::Pop(audPlayConParser);//audPlayConParser

	CMMFAudioPlayControllerSetRepeatsCustomCommandParser* audPlayConSetRepeatsParser = CMMFAudioPlayControllerSetRepeatsCustomCommandParser::NewL(*this);

	CleanupStack::PushL(audPlayConSetRepeatsParser);

	AddCustomCommandParserL(*audPlayConSetRepeatsParser);

	CleanupStack::Pop(audPlayConSetRepeatsParser);

	// [ assert the invariant now that we are constructed ]

	__ASSERT_ALWAYS( Invariant(), Panic( EStateNotConstructed));

	}

/**

1st Phase constructor

@internalComponent

*/

CMMFAudioToneController::CMMFAudioToneController() : iState(EStopped)

	{

	}

/**

Destructor

@internalTechnology

*/

CMMFAudioToneController::~CMMFAudioToneController()

	{

	delete iMMFDevSound;

	delete iToneSequenceData;

	delete iMessage;

	}

/**

Adds a data source to the controller 

@internalTechnology

@param aSource will provide the data the controller plays

*/

void CMMFAudioToneController::AddDataSourceL(MDataSource& aSource)

	{

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic( EBadStateToGetDataSource));

	// [ precondition that the controller is stopped ]

    if( State() != EStopped )

		User::Leave( KErrNotReady );

	//[ precondition iData source is not already configured ]

	if (iDataSource)

		User::Leave(KErrAlreadyExists);

	//Only works with files or descriptors

	if ((aSource.DataSourceType() != KUidMmfFileSource ) && (aSource.DataSourceType() != KUidMmfDescriptorSource))

		User::Leave( KErrNotSupported ) ;

	//extract the tone data into a buffer ready to play.

	iToneSequenceData = CMMFDataBuffer::NewL(STATIC_CAST(CMMFClip*, &aSource)->Size());

	aSource.SourcePrimeL();

	STATIC_CAST(CMMFClip*, &aSource)->ReadBufferL(iToneSequenceData,0);

	aSource.SourceStopL();

	//[ its now safe to set the source ]

	iDataSource = &aSource ;

	//[ assert the post condition ]

	__ASSERT_ALWAYS(iDataSource, Panic(EMMFAudioControllerPanicDataSourceDoesNotExist));

	iDataSource->SetSourcePrioritySettings(iPrioritySettings);

	}

/**

Adds a data sink to the controller 

@internalTechnology

@param aSink will accept the data the controller plays

*/

void CMMFAudioToneController::AddDataSinkL(MDataSink& aSink)

	{

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic( EBadStateToGetDataSink));

	// [ precondition that the controller is stopped ]

    if( State() != EStopped )

		User::Leave( KErrNotReady );

	// [ assert precondition that sink does not exist ]

	if (iMMFDevSound)

		User::Leave(KErrAlreadyExists);

	//Only support playing to audio output 

	if (aSink.DataSinkType() != KUidMmfAudioOutput)

		User::Leave( KErrNotSupported );

	iMMFDevSound = CMMFDevSound::NewL();

	// [ assert post conditions that a sink has been added ]

	__ASSERT_ALWAYS(iMMFDevSound, Panic(EMMFAudioControllerPanicDataSinkDoesNotExist));

	}

/**

Primes the controller, ready for playing

@internalTechnology

@param aMessage allows response to client upon completion or error

*/

void CMMFAudioToneController::PrimeL(TMMFMessage& aMessage)

	{

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic( EBadStateForPrime));

	//[ assert the precondition ( in a friendly way for this api 

	// that we are either stopped or primed already ]

	if(!(( State() == EStopped ) || (State() == EPrimed )))

		User::Leave( KErrNotReady );

	// [ precondition we have a data source & sink and aren't already processing a message]

	__ASSERT_ALWAYS( iDataSource, Panic( ENoDataSource));

	__ASSERT_ALWAYS( iMMFDevSound, Panic( ENoDataSink));

	__ASSERT_ALWAYS( !iMessage, Panic( EMessageAlreadyBeingProcessed ));

	if (iState == EStopped)

		{

		iMessage = new(ELeave) TMMFMessage(aMessage); //store message

		__ASSERT_ALWAYS( iMessage, Panic( EPostConditionViolation )); //check if message created sucessfully

		SetState(EPriming);

		TRAPD(err,NegotiateL());

		if(err != KErrNone)

			{

			SetState( EStopped );

			delete iMessage;

			iMessage = NULL;

			User::Leave(err);

			}

		}

	__ASSERT_ALWAYS( Invariant(), Panic( EStateNotPrimed ) );

	}

/**

Primes the controller, ready for playingAdds a data sink to the controller 

@internalTechnology

*/

void CMMFAudioToneController::PrimeL()

	{

	Panic(EBadCall);

	}

/**

This method resets the controller

@internalTechnology

*/

void CMMFAudioToneController::ResetL()

	{

	__ASSERT_ALWAYS( Invariant(), Panic( EBadStateToReset ) );

	// Stop recording if it's not stopped,

	if (State() != EStopped)

		{

		StopL();

		}

	//[ ensure loggoff of source and sink ]

	iDataSource = NULL ;

	delete iMMFDevSound; iMMFDevSound = NULL ;

	iSourceAndSinkAdded = EFalse;

	delete iMessage;

	iMessage = NULL;

	// [ assert the invariant]

	__ASSERT_ALWAYS( Invariant(), Panic( EBadResetState ) );

	__ASSERT_ALWAYS( ResetPostCondition(), Panic( EBadReset ));

	__ASSERT_ALWAYS( Invariant(), Panic(EBadState));

	}

/**

This function determnines if the reset post condition is valid

@internalComponent

*/

TBool CMMFAudioToneController::ResetPostCondition() const

	{

     TBool result = EFalse ;

	if((iMMFDevSound == NULL)  &&

	(iDataSource == NULL)  && 

	(State() == EStopped))

		{

         result = ETrue;

		}

    return result;

	}

/**

Start playing the audio tone, passing the data to Dev Sound

The controller will be put into the EPlaying state

@internalTechnology

*/

void CMMFAudioToneController::PlayL()

	{

	// [ assert the precondition that the

	//   play command is only activated in the primed state]

	if ( State() != EPrimed && State() != EPausePlaying)

		User::Leave(KErrNotReady);

	// [ assert the Invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EStateNotReadyToPlay));

	if(State() == EPausePlaying && iIsResumeSupported)

		{

		User::LeaveIfError(iMMFDevSound->Resume());

		}

	else

		{

		iMMFDevSound->PlayToneSequenceL(iToneSequenceData->Data());	

		}

	SetState( EPlaying );

	//[ assert the post condition we are playing ]

	__ASSERT_ALWAYS( (State() == EPlaying ), Panic( EBadState));

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadPlayState));

	}

/**

This should Pause playing of the audio tone. HOWEVER, this is not possible with a 

tone sequence. This method is therefore provided as a NOP purely to allow audio

clients to operate correctly.

The controller will be put into the EPrimed state

@internalTechnology

 */

void CMMFAudioToneController::PauseL()

	{

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadStateToPause));

	__ASSERT_ALWAYS(iMMFDevSound, Panic(EMMFAudioControllerPanicDataSinkDoesNotExist));

	if(iIsResumeSupported)

		{

		iMMFDevSound->Pause();

		SetState(EPausePlaying);

		}

	else

		{

		// If Resume is not supported 

		// this method can't do anything, as we have no interface to restart DevSound 

		// after pausing a tone. It need to be here however as client utility does

		// Pause() Stop() when stopping.

		SetState(EPrimed);

		}

	//[ assert the post condition we are stopped ]

	__ASSERT_ALWAYS( (State() == EPrimed || State() == EPausePlaying), Panic( EBadState));

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadPauseState));

	}

/**

This stops the tone that is currently playing

The controller will be put into the EStopped state

@internalTechnology

*/

void CMMFAudioToneController::StopL()

	{

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadStateToStop));

	// [ precondition that we are not already stopped 

	// && if we are stopped do nothing.

	// Due to the asynchronous nature of the controller

	// interaction the response to stopped when stopped 

	// should not be an error ]

	if (State() != EStopped)

		{

		//[ update state to stopped propogate to devsound ]

		iMMFDevSound->Stop();

		SetState(EStopped);

		}

	//[ assert the post condition we are stopped ]

	__ASSERT_ALWAYS( (State() == EStopped), Panic( EBadState));

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadStopState));

	}

/**

Removes a data source form the controller

@internalTechnology

@param aDataSource The source that is to be removed.

*/

void CMMFAudioToneController::RemoveDataSourceL(MDataSource& aDataSource )

	{

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(ENotReadyForDataSourceRemoval) );

	//[ precondition is that we have a data source ]

	if( !iDataSource )

		User::Leave(KErrNotReady);

	//[precondition the data source is the data source we have]

	if( iDataSource != &aDataSource )

		User::Leave(KErrArgument);

	//[ the controller is in the stopped state ]

	if(State() != EStopped)

		User::Leave(KErrNotReady);

	//[ remove the data sink from the controller and delete the format]

     if( iSourceAndSinkAdded )

		{

		iMMFDevSound->Stop();

		iSourceAndSinkAdded = EFalse ;

		}

	 iDataSource = NULL ;

	// [ assert postcondition we are stopped ]

	__ASSERT_ALWAYS( (State() == EStopped), Panic(EPostConditionViolation) );

	//[ assert postcondition the SourceAndSinkAdded is false ]

	__ASSERT_ALWAYS( !iSourceAndSinkAdded, Panic( EPostConditionViolation ));

	//[ assert postcondition the data sink  is null ]

	__ASSERT_ALWAYS( (iDataSource == NULL ), Panic( EPostConditionViolation ));

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadDataSourceRemoval));

	}

/**

Removes a data sink form the controller

@internalTechnology

@param aDataSink The sink that is to be removed. We donot 

use this value, as we only support a single sink. 

*/

void CMMFAudioToneController::RemoveDataSinkL(MDataSink& /*aDataSink*/)

	{

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(ENotReadyForDataSinkRemoval) );

	//[ precondition is that we have a data sink ]

	if(!iMMFDevSound)

		User::Leave(KErrNotReady);

	//[ the controller is in the stopped state ]

	if(State() != EStopped)

		User::Leave(KErrNotReady);

	//[ remove the data sink from the controller and delete the format]

     if(iSourceAndSinkAdded)

		{

		iMMFDevSound->Stop();

		iSourceAndSinkAdded = EFalse;

		}

	delete iMMFDevSound; iMMFDevSound = NULL;

	// [ assert postcondition we are stopped ]

	__ASSERT_ALWAYS( (State() == EStopped), Panic(EPostConditionViolation) );

	//[ assert postcondition the SourceAndSinkAdded is false ]

	__ASSERT_ALWAYS( !iSourceAndSinkAdded, Panic( EPostConditionViolation ));

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadDataSinkRemoval));

	}

/**

Handles a CustomCommand for the controller. This controller doesn't support Custom Commands

@internalTechnology

@param aMessage

*/

void CMMFAudioToneController::CustomCommand(TMMFMessage& aMessage)

	{

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(ENotReadyForCustomCommand));

	// [ We do not have any custom commands ]

	aMessage.Complete(KErrNotSupported);

	}

/**

Configures Dev Sound, ready for playing.

@internalComponent

*/

void CMMFAudioToneController::NegotiateL()

	{

	if (!iMMFDevSound)

		Panic(EMMFAudioOutputDevSoundNotLoaded);

	iMMFDevSound->InitializeL(*this, EMMFStateTonePlaying);

	iMMFDevSound->SetPrioritySettings(iPrioritySettings);

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadStateAfterNegotiate));

	}

/**

Set the priority settings that this controller should use to access Dev Sound

@internalTechnology

@param aPrioritySettings The requires priority settings

*/

void CMMFAudioToneController::SetPrioritySettings(const TMMFPrioritySettings& aPrioritySettings)

	{

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadStateToSetPriority));

	//[ assert the precondition ]

	if(State() != EStopped)

		{

		ASSERT(EFalse);		// used to leave here with KErrNotReady

		return;

		}

	//[ update the priority settings of the controller]

	iPrioritySettings = aPrioritySettings;

	if (iMMFDevSound)

		{

		iMMFDevSound->SetPrioritySettings(iPrioritySettings);

		}

	__ASSERT_ALWAYS( Invariant(), Panic(EBadPriorityState));

	}

/**

This method is called by DevSound after initialization, indicating that it has completed and 

whether there was an error

@internalTechnology

@param aError the error supplied by Dev Sound

*/

void CMMFAudioToneController::InitializeComplete(TInt aError)

	{

	//[ assert the state is EPriming ]

	__ASSERT_ALWAYS( ( State() == EPriming ), Panic( EBadState ));

	__ASSERT_ALWAYS( iMessage, Panic( ENoMessageToProcess ));

	if(aError != KErrNone)

		{

		SetState( EStopped );

		iMessage->Complete(aError);

		}

	else 

		{

		SetState( EPrimed );

		iMessage->Complete(aError);

		iIsResumeSupported = iMMFDevSound->IsResumeSupported();

		}

	delete iMessage;

	iMessage = NULL;

	// [ assert the invariant]	

	__ASSERT_ALWAYS( Invariant(), Panic( EBadInitializeState ) );

	}

/**

This method is called by DevSound after it has finished playing a tone sequence, indicating 

whether there was an error

@internalTechnology

@param aError the error supplied by DevSound

*/

void CMMFAudioToneController::ToneFinished(TInt aError)

	{

	// NB KErrInUse, KErrDied OR KErrAccessDenied may be returned 

	// to indicate that the sound device is in use  by another higher 

	// priority client.

	if (aError == KErrCancel || aError == KErrInUse || 

	    aError == KErrDied || aError == KErrAccessDenied)

		return;

	if (aError == KErrUnderflow)

		aError = KErrNone;

	if (State() != EStopped)

		{

		iMMFDevSound->Stop();

		SetState( EStopped );

		}

	//now send event to client...

	TMMFEvent event;

	event.iEventType = KMMFEventCategoryPlaybackComplete;

	event.iErrorCode = aError;

	DoSendEventToClient(event);	

	}

/**

Called my DevSound to indicate we have been thrown off H/W by a higher priority

@internalTechnology

@param aEvent contains the reason we have been contacted by DevSound

*/

void CMMFAudioToneController::SendEventToClient(const TMMFEvent& aEvent)

	{

	if(State() == EPlaying)

		SetState(EStopped);

	DoSendEventToClient(aEvent);	

	}

/**

Sets the playback volume

@internalTechnology

@param aVolume the required volume

*/

void CMMFAudioToneController::MapdSetVolumeL(TInt aVolume)

	{

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadStateToSetVolume));

	// [  precondition is true for state 

	//    we can set the volume in any state ]

	//[ precondition we have a data sink ]

	if (!iMMFDevSound)

		User::Leave(KErrNotReady);

	// [ assert the precondition that aVolume is in range ]

	TInt maxVolume = iMMFDevSound->MaxVolume();

	if( ( aVolume < 0 ) || ( aVolume > maxVolume ))

		User::Leave(KErrArgument);

	//[ set the volume on the device ]

	iMMFDevSound->SetVolume(aVolume);

	//[ assert the post condition volume is equal to a volume]

	TInt soundVolume = 0;

	soundVolume = iMMFDevSound->Volume();

    __ASSERT_ALWAYS( ( soundVolume == aVolume), Panic(EPostConditionViolation));

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadStateAfterVolumeSet));

	}

/**

Gets the maximum level the playback volume can be set to

@internalTechnology

@param aMaxVolume contains the maximum volume setting

*/

void CMMFAudioToneController::MapdGetMaxVolumeL(TInt& aMaxVolume)

	{

	// [ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadStateToGetMaxVolume));

	//[ precondition we have a data sink ]

	if (!iMMFDevSound)

		User::Leave(KErrNotReady);

	//[ get the volume from the device ]

	aMaxVolume = iMMFDevSound->MaxVolume();

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadStateAfterGetMaxVolume));

	}

/**

Gets the current playback volume

@internalTechnology

@param aVolume the current volume

*/

void CMMFAudioToneController::MapdGetVolumeL(TInt& aVolume)

	{

	// [ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadStateToGetVolume));

	//[  precondition that we have a data sink ]

	if (!iMMFDevSound)

		User::Leave(KErrNotReady);

	aVolume = iMMFDevSound->Volume();

	// [ assert precondition that the volume is in range

	//     0.. aMaxVolume ]

	TInt aMaxVolume = iMMFDevSound->MaxVolume();

	__ASSERT_ALWAYS( (aVolume <= aMaxVolume), Panic(EBadState));

	__ASSERT_ALWAYS( (aVolume >= 0), Panic(EBadState));

	// [ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadStateAfterGetVolume));

	}

/**

Sets the duration over which the volume should increase

@internalTechnology

@param aRampDuration the time over which the volume should ramp

*/

void CMMFAudioToneController::MapdSetVolumeRampL(const TTimeIntervalMicroSeconds& aRampDuration)

	{

     // [ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadStateToSetVolumeRamp));

	//[ precondition that we have a data sink ]

	if (!iMMFDevSound)

		User::Leave(KErrNotReady);

	iMMFDevSound->SetVolumeRamp(aRampDuration);

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadStateAfterSetVolumeRamp));

	}

/**

Sets the balance of the tone playback

@internalTechnology

@param aBalance the required balance level (KMMFBalanceMaxLeft <= aBalance <= KMMFBalanceMaxRight)

*/

void CMMFAudioToneController::MapdSetBalanceL(TInt aBalance)

	{

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic( EBadStateToSetBalance));

	// [ precondition is that we have a data sink ]

	if (!iMMFDevSound)

		User::Leave(KErrNotReady);

	// [ separate out left and right balance ]

	TInt left  = 0;

	TInt right = 0;

	CalculateLeftRightBalance( left, right, aBalance );

	//[ set the balance ]

	iMMFDevSound->SetPlayBalanceL(left, right); 

	// [assert the post condition that the balance is set correctly]

	TInt rightBalance = 0;

	TInt leftBalance  = 0;

	iMMFDevSound->GetPlayBalanceL(leftBalance, rightBalance); 

	//[ assert post condition holds]

	TBool postCondition = (( rightBalance == right) && ( leftBalance == left));

	__ASSERT_ALWAYS( postCondition, Panic( EPostConditionViolation ) );

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic( EBadStateAfterSetBalance));

	}

/**

Converts the balance from a range to a left/right form.

Balance is provided to devsound using left and right levels, but supplied to the controller as a range 

(KMMFBalanceMaxLeft --> KMMFBalanceMaxRight). This method converts the range into a left/right form

@internalComponent

@param aLeft set to the left setting

@param aRight set to the right setting

@param aBalance the range required

*/

void CMMFAudioToneController::CalculateLeftRightBalance( TInt& aLeft, TInt& aRight, TInt aBalance ) const

	{

	// Check the balance is within limits & modify to min or max values if necessary

	if (aBalance < KMMFBalanceMaxLeft)

		aBalance = KMMFBalanceMaxLeft;

	if (aBalance > KMMFBalanceMaxRight)

		aBalance = KMMFBalanceMaxRight;

	//[ Now separate percentage balances out from aBalance ]

	 aLeft = (100 * (aBalance-KMMFBalanceMaxRight)) / (KMMFBalanceMaxLeft-KMMFBalanceMaxRight);

     aRight = 100 - aLeft;

	 //[ assert post condition that left and right are within range ]

	 __ASSERT_ALWAYS( ( (aLeft <= 100) && (aLeft >= 0) ), Panic(EPostConditionViolation));

	 __ASSERT_ALWAYS( ( (aRight <= 100) && (aRight >= 0) ), Panic(EPostConditionViolation));

	}

/**

Gets the balance of the tone playback

@internalTechnology

@param aBalance set to the current balance level (KMMFBalanceMaxLeft <= aBalance <= KMMFBalanceMaxRight)

*/

void CMMFAudioToneController::MapdGetBalanceL(TInt& aBalance)

	{

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadStateToGetBalance));

	//[ precondition that we have a sink]

	if (!iMMFDevSound)

		User::Leave(KErrNotReady);

	TInt left = 50; // arbitrary values 

	TInt right = 50;

	iMMFDevSound->GetPlayBalanceL(left, right); 

    CalculateBalance( aBalance, left, right );

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadStateAfterGetBalance));

	}

/**

Converts the balance from a left/right form to a range.

Balance is obtained from  DevSound using left and right levels, but supplied to the client as a range 

(KMMFBalanceMaxLeft --> KMMFBalanceMaxRight).

@internalComponent

@param aLeft the current left setting

@param aRight current right setting

@param aBalance set to the balance range

*/

void CMMFAudioToneController::CalculateBalance( TInt& aBalance, TInt aLeft, TInt aRight ) const

	{

	//[ assert pre conditions ]

	__ASSERT_ALWAYS( (( aLeft + aRight ) == 100 ), Panic( EBadArgument ));

	__ASSERT_ALWAYS( (( 0 <= aLeft) && ( 100 >= aLeft)), Panic( EBadArgument) );

	__ASSERT_ALWAYS( (( 0 <= aRight) && ( 100 >= aRight)), Panic( EBadArgument) );

	aBalance = (aLeft * (KMMFBalanceMaxLeft-KMMFBalanceMaxRight))/100 + KMMFBalanceMaxRight;

    //[ assert post condition that aBalance is within limits ]

	__ASSERT_ALWAYS( !(aBalance < KMMFBalanceMaxLeft || aBalance > KMMFBalanceMaxRight), Panic(EBadArgument));

	}

/**

The function validates a state transition from iState to aState and 

returns ETrue if the transition is allowed.

@internalComponent

@param TControllerState

@return Valid controller state or not 

*/

TBool CMMFAudioToneController::IsValidStateTransition( TControllerState aState ) const

	{

	 TBool result = ETrue ;

	//[ assert the precondition that aState is a valid State ]

	__ASSERT_ALWAYS( IsValidState(aState), Panic( EBadArgument ) );

	//[ assert the invariant that iState is a valid State ]

	__ASSERT_ALWAYS( Invariant(), Panic( EBadStateForTransition ));

	// [ check the valid state transitions ]

	  // the only invalid transition is

	  // stopped to playing

	if( ( iState == EStopped ) && ( aState == EPlaying ))

		{

         result = EFalse ;

		}

	//[ assert the invariant that iState is a valid State ]

	__ASSERT_ALWAYS( Invariant(), Panic( EBadStateAfterTransition ));

	return result ;

	}

/*

This function returns whether the invariant is valid

@internalComponent

@return Is the class in a good condition

*/

TBool  CMMFAudioToneController::Invariant() const

	{

	//[ The invariant is for now defined 

	// as simply being in the correct state

	return IsValidState( iState);

	}

/*

This function sets the state of the controller.

@internalComponent

@return Whether ths state transition is valid

*/

TBool CMMFAudioToneController::SetState(TControllerState aState)

	{

	TBool result = ETrue;

	//[ assert the precondition that the state is a valid state ]

   	__ASSERT_ALWAYS( IsValidState( aState),  Panic( EBadArgument ) );

	//[ assert the invariant the current state is valid ]

	__ASSERT_ALWAYS( Invariant(),  Panic( EStateNotValid ) );

    //[ only allow valid state transitions ]

	if( IsValidStateTransition( aState ) )	

		{

		//[ valid state transition set the state]

		iState = aState ;

		}

	else

		{

		//[ invalid state transition return EFalse ]

		result = EFalse;         

		}

	// [ assert the invariant on the state ]

	__ASSERT_ALWAYS( Invariant(), Panic( EBadState ));

	return result ;

	}

/*

checks whether a state is valid 

@internalComponent

@return Is the state a valid one

*/

TBool  CMMFAudioToneController::IsValidState( TControllerState aState ) const 

	{

	TBool result = EFalse;

     if(( aState >= EStopped ) && ( aState <= EPlaying ))

		 {

          result = ETrue;

		 }

	 return result;

	}

/**

The function State returns the current state of the audio controller

@internalComponent