// 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/common/mmfpaniccodes.h>

 #include "mmfclienttoneplayer.h"

 using namespace ContentAccess;

 enum TMmfMdaAudioToneUtility

 	{

 	EBadArgument,

 	EPostConditionViolation, 

 	EPlayStartedCalledWithError

 	};

 // declared in the recorder module

 void Panic(TInt aPanicCode);

 /**

 Creates a new instance of the tone player utility.

 The default  volume is set to MaxVolume() / 2.

 @param  aObserver

         A class to receive notifications from the tone player.

 @param  aServer

         This parameter is no longer used and should be NULL.

 @return A pointer to the new audio tone player utility object.

 @since 5.0

 */

 EXPORT_C CMdaAudioToneUtility* CMdaAudioToneUtility::NewL(MMdaAudioToneObserver& aObserver, CMdaServer* aServer /*= NULL*/)

 	{

 	return CMdaAudioToneUtility::NewL(aObserver, aServer, EMdaPriorityNormal, EMdaPriorityPreferenceTimeAndQuality);

 	}

 /**

 Creates a new instance of the tone player utility.

 The default  volume is set to MaxVolume() / 2.

 @param  aObserver

         A class to receive notifications from the tone player

 @param  aServer

         This parameter is no longer used and should be NULL

 @param  aPriority

         The Priority Value - this client's relative priority. This is a value between EMdaPriorityMin and 

         EMdaPriorityMax and represents a relative priority. A higher value indicates a more important request.

 @param  aPref

         The Priority Preference - an additional audio policy parameter. The suggested default is 

         EMdaPriorityPreferenceNone. Further values are given by TMdaPriorityPreference, and additional 

         values may be supported by given phones and/or platforms, but should not be depended upon by 

         portable code.

 @return A pointer to the new audio tone player utility object.

 @since 5.0

 Note: The Priority Value and Priority Preference are used primarily when deciding what to do when

 several audio clients attempt to play or record simultaneously. In addition to the Priority Value and Preference, 

 the adaptation may consider other parameters such as the SecureId and Capabilities of the client process. 

 Whatever, the decision  as to what to do in such situations is up to the audio adaptation, and may

 vary between different phones. Portable applications are advised not to assume any specific behaviour. 

 */

 EXPORT_C CMdaAudioToneUtility* CMdaAudioToneUtility::NewL(MMdaAudioToneObserver& aObserver, CMdaServer* /*aServer = NULL*/,

 														  TInt aPriority /*= EMdaPriorityNormal*/,

 														  TInt aPref /*= EMdaPriorityPreferenceTimeAndQuality*/)

 	{

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

 	CleanupStack::PushL(self);

 	self->iProperties = CMMFMdaAudioToneUtility::NewL(aObserver, NULL, aPriority, aPref);

 	CleanupStack::Pop(); //self

 	return self;

 	}

 /**

 Destructor. Frees any resources held by the tone player

 @since 5.0

 */

 CMdaAudioToneUtility::~CMdaAudioToneUtility()

 	{

 	delete iProperties;

 	}

 /**

 Returns the current state of the audio tone utility.

 @return The state of the audio tone utility.

 @since  5.0

 */

 TMdaAudioToneUtilityState CMdaAudioToneUtility::State()

 	{

 	ASSERT(iProperties);

 	return iProperties->State();

 	}

 /**

 Returns the maximum volume supported by the device. This is the maximum value which can be 

 passed to CMdaAudioToneUtility::SetVolume().

 @return The maximum volume. This value is platform dependent but is always greater than or equal to one.

 @since  5.0

 */

 TInt CMdaAudioToneUtility::MaxVolume()

 	{

 	ASSERT(iProperties);

 	return iProperties->MaxVolume();

 	}

 /**

 Returns an integer representing the current volume of the audio device.

 @return The current volume.

 @since 		5.0

 */

 TInt CMdaAudioToneUtility::Volume()

 	{

 	ASSERT(iProperties);

 	return iProperties->Volume();

 	}

 /**

 Changes the volume of the audio device.

 The volume can be changed before or during play and is effective

 immediately.

 @param  aVolume

         The volume setting. This can be any value from zero to

         the value returned by a call to

         CMdaAudioToneUtility::MaxVolume().

         Setting a zero value mutes the sound. Setting the

         maximum value results in the loudest possible sound.

 @since  5.0

 */

 void CMdaAudioToneUtility::SetVolume(TInt aVolume)

 	{

 	ASSERT(iProperties);

 	iProperties->SetVolume(aVolume);

 	}

 /**

 Changes the clients priority.

 @param  aPriority

         The Priority Value.

 @param  aPref

         The Priority Preference.

 @see CMdaAudioToneUtility::NewL()

 @since  5.0

 */

 void CMdaAudioToneUtility::SetPriority(TInt aPriority, TInt aPref)

 	{

 	ASSERT(iProperties);

 	iProperties->SetPriority(aPriority, aPref);

 	}

 /**

 Changes the duration of DTMF tones, the gaps between DTMF tones and the

 pauses.

 @param  aToneLength

         The duration of the DTMF tone in microseconds.

 @param  aToneOffLength

         The gap between DTFM tones in microseconds.

 @param  aPauseLength

         Pauses in microseconds

 */

 void CMdaAudioToneUtility::SetDTMFLengths(TTimeIntervalMicroSeconds32 aToneLength,

 										  TTimeIntervalMicroSeconds32 aToneOffLength,

 										  TTimeIntervalMicroSeconds32 aPauseLength)

 	{

 	ASSERT(iProperties);

 	iProperties->SetDTMFLengths(aToneLength, aToneOffLength, aPauseLength);

 	}

 /**

 Sets the number of times the tone sequence is to be repeated during

 the play operation.

 A period of silence can follow each playing of the tone sequence. The

 tone sequence can be repeated indefinitely.

 @param  aRepeatNumberOfTimes

         The number of times the tone sequence, together with

         the trailing silence, is to be repeated. If this is

         set to KMdaRepeatForever, then the tone

         sequence, together with the trailing silence, is

         repeated indefinitely. The behaviour is undefined for values other than  

 		KMdaRepeatForever, zero and positive.

 @param  aTrailingSilence

         The time interval of the training silence. The behaviour is undefined

         for values other than zero and positive.

 @since  5.0

 */

 void CMdaAudioToneUtility::SetRepeats(TInt aRepeatNumberOfTimes,

 									  const TTimeIntervalMicroSeconds& aTrailingSilence)

 	{

 	ASSERT(iProperties);

 	iProperties->SetRepeats(aRepeatNumberOfTimes, aTrailingSilence);

 	}

 /**

 Defines the period over which the volume level is to rise smoothly

 from nothing to the normal volume level.

 @param  aRampDuration

         The period over which the volume is to rise. A zero

         value causes the tone to be played at the normal level

         for the full duration of the playback. A value which

         is longer than the duration of the tone sequence means

         that the tone never reaches its normal volume level.

 @since  5.0

 */

 void CMdaAudioToneUtility::SetVolumeRamp(const TTimeIntervalMicroSeconds& aRampDuration)

 	{

 	ASSERT(iProperties);

 	iProperties->SetVolumeRamp(aRampDuration);

 	}

 /**

 Returns the number of available pre-defined tone sequences.

 @return The number of tone sequences. This value is implementation 

 		dependent but is always greater than or equal to zero.

 @since  5.0

 */

 TInt CMdaAudioToneUtility::FixedSequenceCount()

 	{

 	ASSERT(iProperties);

 	return iProperties->FixedSequenceCount();

 	}

 /**

 Returns the name assigned to a specific pre-defined tone sequence.

 @param  aSequenceNumber

         The index identifying the specific pre-defined tone sequence. 

         Index values are relative to zero. This can be any value from 

         zero to the value returned by a call to FixedSequenceCount() - 1.

         The function raises a panic if sequence number is not within this

  		range.

 @see CMMFDevSound::FixedSequenceName(TInt aSequenceNumber)

 @see FixedSequenceCount()

 @return The name assigned to the tone sequence.

 @since  5.0

 */

 const TDesC& CMdaAudioToneUtility::FixedSequenceName(TInt aSequenceNumber)

 	{

 	ASSERT(iProperties);

 	return iProperties->FixedSequenceName(aSequenceNumber);

 	}

 /**

 Configures the audio tone player utility to play a single tone.

 This function is asynchronous. On completion, the observer callback

 function MMdaAudioToneObserver::MatoPrepareComplete() is

 called, indicating the success or failure of the configuration

 operation.The configuration operation can be cancelled by calling

 CMdaAudioToneUtility::CancelPrepare(). The configuration

 operation cannot be started if a play operation is in progress.

 @param     aFrequency

            The frequency (pitch) of the tone in Hz.

 @param     aDuration

            The duration of the tone in microseconds.

 @since     5.0

 */

 void CMdaAudioToneUtility::PrepareToPlayTone(TInt aFrequency, const TTimeIntervalMicroSeconds& aDuration)

 	{

 	ASSERT(iProperties);

 	iProperties->PrepareToPlayTone(aFrequency, aDuration);

 	}

 /**

 Configures the audio tone player utility to play a dual tone.

 The generated tone consists of two sine waves of different

 frequencies summed together.

 This function is asynchronous. On completion, the observer callback

 function MMdaAudioToneObserver::MatoPrepareComplete() is

 called, indicating the success or failure of the configuration

 operation. The configuration operation can be cancelled by calling

 CMdaAudioToneUtility::CancelPrepare(). The configuration

 operation cannot be started if a play operation is in progress.

 @param  aFrequencyOne

         The first frequency (pitch) of the tone.

 @param  aFrequencyTwo

         The second frequency (pitch) of the tone.

 @param  aDuration

         The duration of the tone in microseconds.

 @since  7.0sy

 */

 EXPORT_C void CMdaAudioToneUtility::PrepareToPlayDualTone(TInt aFrequencyOne, TInt aFrequencyTwo, const TTimeIntervalMicroSeconds& aDuration)

 	{

 	ASSERT(iProperties);

 	iProperties->PrepareToPlayDualTone(aFrequencyOne, aFrequencyTwo, aDuration);

 	}

 /**

 Configures the audio tone utility player to play a DTMF (Dual-Tone

 Multi-Frequency) string.

 This function is asynchronous. On completion, the observer callback

 function MMdaAudioToneObserver::MatoPrepareComplete() is

 called, indicating the success or failure of the configuration

 operation. The configuration operation can be cancelled by calling

 CMdaAudioToneUtility::CancelPrepare(). The configuration

 operation cannot be started if a play operation is in progress.

 @param  aDTMF

         A descriptor containing the DTMF string.

 @since  5.0

 */

 void CMdaAudioToneUtility::PrepareToPlayDTMFString(const TDesC& aDTMF)

 	{

 	ASSERT(iProperties);

 	iProperties->PrepareToPlayDTMFString(aDTMF);

 	}

 /**

 Configures the audio tone player utility to play a tone sequence

 contained in a descriptor.

 This function is asynchronous. On completion, the observer callback

 function MMdaAudioToneObserver::MatoPrepareComplete() is

 called, indicating the success or failure of the configuration

 operation. The configuration operation can be cancelled by calling

 CMdaAudioToneUtility::CancelPrepare(). The configuration

 operation cannot be started if a play operation is in progress.

 @param  aSequence

         The descriptor containing the tone sequence. The

         format of the data is unspecified but is expected to

         be platform dependent. A device might support more

         than one form of sequence data.

 @since  5.0

 */

 void CMdaAudioToneUtility::PrepareToPlayDesSequence(const TDesC8& aSequence)

 	{

 	ASSERT(iProperties);

 	iProperties->PrepareToPlayDesSequence(aSequence);

 	}

 /**

 Configures the audio tone player utility to play a tone sequence

 contained in a file.

 This function is asynchronous. On completion, the observer callback

 function MMdaAudioToneObserver::MatoPrepareComplete() is

 called, indicating the success or failure of the configuration

 operation. The configuration operation can be cancelled by calling

 CMdaAudioToneUtility::CancelPrepare(). The configuration

 operation cannot be started if a play operation is in progress.

 @param  aFileName

         The full path name of the file containing the tone

         sequence. The format of the data is unspecified but is

         expected to be platform dependent. A device might

         support more than one form of sequence data.

 @since  5.0

 */

 void CMdaAudioToneUtility::PrepareToPlayFileSequence(const TDesC& aFileName)

 	{

 	ASSERT(iProperties);

 	iProperties->PrepareToPlayFileSequence(aFileName);

 	}

 /**

 Configures the audio tone player utility to play a tone sequence

 contained in a file.

 This function is asynchronous. On completion, the observer callback

 function MMdaAudioToneObserver::MatoPrepareComplete() is

 called, indicating the success or failure of the configuration

 operation. The configuration operation can be cancelled by calling

 CMdaAudioToneUtility::CancelPrepare(). The configuration

 operation cannot be started if a play operation is in progress.

 @param  aFile

         A handle to an open file containing the tone

         sequence. The format of the data is unspecified but is

         expected to be platform dependent. A device might

         support more than one form of sequence data.

 @since  5.0

 */

 EXPORT_C void CMdaAudioToneUtility::PrepareToPlayFileSequence(RFile& aFile)

 	{

 	ASSERT(iProperties);

 	iProperties->PrepareToPlayFileSequence(aFile);

 	}

 /**

 Configures the audio tone player utility to play the specified

 pre-defined tone sequence.

 This function is asynchronous. On completion, the observer callback

 function MMdaAudioToneObserver::MatoPrepareComplete() is

 called, indicating the success or failure of the configuration

 operation. The configuration operation can be cancelled by calling

 CMdaAudioToneUtility::CancelPrepare(). The configuration

 operation cannot be started if a play operation is in progress.

 @param  aSequenceNumber

         An index into the set of pre-defined tone sequences.

         This can be any value from zero to the value returned by a 

         call to FixedSequenceCount() - 1.

         If the sequence number is not within this range, a panic will be 

         raised when Play() is called later.

 @see FixedSequenceCount()

 @see CMMFDevSound::PlayFixedSequenceL(TInt aSequenceNumber)

 @since  5.0

 */

 void CMdaAudioToneUtility::PrepareToPlayFixedSequence(TInt aSequenceNumber)

 	{

 	ASSERT(iProperties);

 	iProperties->PrepareToPlayFixedSequence(aSequenceNumber);

 	}

 /**

 Cancels the configuration operation.

 The observer callback function

 MMdaAudioToneObserver::MatoPrepareComplete() is not

 called.

 @since  5.0

 */

 void CMdaAudioToneUtility::CancelPrepare()

 	{

 	ASSERT(iProperties);

 	iProperties->CancelPrepare();

 	}

 /**

 Plays the tone.

 The tone played depends on the current configuration.This function is

 asynchronous. On completion, the observer callback function

 MMdaAudioToneObserver::MatoPlayComplete() is called,

 indicating the success or failure of the play operation.The play

 operation can be cancelled by

 calling CMdaAudioToneUtility::CancelPlay().

 @since  5.0

 */

 void CMdaAudioToneUtility::Play()

 	{

 	ASSERT(iProperties);

 	iProperties->Play();

 	}

 EXPORT_C TInt CMdaAudioToneUtility::Pause()

 	{

 	ASSERT(iProperties);

 	return iProperties->Pause();

 	}

 EXPORT_C TInt CMdaAudioToneUtility::Resume()

 	{

 	ASSERT(iProperties);

 	return iProperties->Resume();

 	}

 /**

 Cancels the tone playing operation.

 The observer callback

 function MMdaAudioToneObserver::MatoPlayComplete() is not

 called.

 @since  5.0

 */

 void CMdaAudioToneUtility::CancelPlay()

 	{

 	ASSERT(iProperties);

 	iProperties->CancelPlay();

 	}

 /**

 Sets the stereo balance for playback.

 @param 	aBalance

         The balance. Should be between KMMFBalanceMaxLeft and KMMFBalanceMaxRight.

 @return An error code indicating if the function call was successful. KErrNone on success, otherwise

         another of the system-wide error codes.

 @since 7.0s

 */

 EXPORT_C void CMdaAudioToneUtility::SetBalanceL(TInt aBalance /*=KMMFBalanceCenter*/)

 	{

 	ASSERT(iProperties);

 	iProperties->SetBalanceL(aBalance);

 	}

 /**

  *	Returns The current playback balance.This function may not return the same value 

  *			as passed to SetBalanceL depending on the internal implementation in 

  *			the underlying components.

  *

  *	@return The balance. Should be between KMMFBalanceMaxLeft and KMMFBalanceMaxRight.

  *		

  *  @since 	7.0s

  */

 EXPORT_C TInt CMdaAudioToneUtility::GetBalanceL()

 	{

 	ASSERT(iProperties);

 	return iProperties->GetBalanceL();

 	}

 /**

 Retrieves a custom interface to the underlying device.

 @param  aInterfaceId

         The interface UID, defined with the custom interface.

 @return A pointer to the interface implementation, or NULL if the device does not

         implement the interface requested. The return value must be cast to the

         correct type by the user.

 */

 EXPORT_C TAny* CMdaAudioToneUtility::CustomInterface(TUid aInterfaceId)

 	{

 	ASSERT(iProperties);

 	return iProperties->CustomInterface(aInterfaceId);

 	}

 EXPORT_C void CMdaAudioToneUtility::RegisterPlayStartCallback(MMdaAudioTonePlayStartObserver& aObserver)

 	{

 	ASSERT(iProperties);

 	iProperties->RegisterPlayStartCallback(aObserver);

 	}

 CMMFMdaAudioToneUtility* CMMFMdaAudioToneUtility::NewL(MMdaAudioToneObserver& aObserver, CMdaServer* /*aServer = NULL*/,

 														  TInt aPriority /*= EMdaPriorityNormal*/, 

 														  TInt aPref /*= EMdaPriorityPreferenceTimeAndQuality*/)

 	{

 	CMMFMdaAudioToneUtility* self = new(ELeave) CMMFMdaAudioToneUtility(aObserver, aPriority, aPref);

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop(self);

 	return self;

 	}

 CMMFMdaAudioToneUtility::CMMFMdaAudioToneUtility(MMdaAudioToneObserver& aCallback, TInt aPriority, TInt aPref) :

 	iCallback(aCallback)

 	{

 	iPrioritySettings.iPref = aPref;

 	iPrioritySettings.iPriority = aPriority;

 	iState = EMdaAudioToneUtilityNotReady;

 	iInitialized = EFalse;

 	iPlayCalled = EFalse;

 #ifdef _DEBUG

 	iPlayCalledBeforeInitialized = EFalse;

 #endif

 	}

 void CMMFMdaAudioToneUtility::ConstructL()

 	{

 	iAsyncCallback = CMMFMdaAudioToneObserverCallback::NewL(*this, *this);

 	iDevSound = CMMFDevSound::NewL();

 	iDevSound->InitializeL(*this,EMMFStateTonePlaying);

 	// In some implementations InitializeComplete() returns in the InitializeL() context,

 	// check the error

 	User::LeaveIfError(iInitializeState);

 	iDevSound->SetPrioritySettings(iPrioritySettings);

 	SetVolume(MaxVolume()/2 ); // set the volume to an intermediate value 

 	}

 CMMFMdaAudioToneUtility::~CMMFMdaAudioToneUtility()

 	{

 	delete iDevSound;

 	delete iAsyncCallback;

 	delete iToneConfig;

 	}

 void CMMFMdaAudioToneUtility::InitializeComplete(TInt aError)

 	{

 #ifdef _DEBUG

 	__ASSERT_ALWAYS(!iPlayCalledBeforeInitialized, User::Panic(_L("PlayInitialized called before InitializeComplete"), 0));

 #endif

 	iInitialized = ETrue;

 	if (iPlayCalled)

 		{

 		// Play() is called before InitializeComplete()

 		if (aError == KErrNone)

 			{

 			PlayAfterInitialized();

  			}

  		else 

  			{

  			// InitializeComplete() with error other than KErrNone

 			iState = EMdaAudioToneUtilityNotReady;

 			iAsyncCallback->MatoPlayComplete(aError);

  			}

  		iPlayCalled = EFalse;

 		}

  	iInitializeState = aError;

 	}

 void CMMFMdaAudioToneUtility::ToneFinished(TInt aError)

 	{

 	if (aError != KErrCancel)

 		{

 		if (aError == KErrUnderflow)

 			{

 			aError = KErrNone;

 			}

 		iAsyncCallback->MatoPlayComplete(aError);

 		}

 	// else don't want to callback after a cancel

 	}

 TMdaAudioToneUtilityState CMMFMdaAudioToneUtility::State()

 	{

 	return iState;

 	}

 TInt CMMFMdaAudioToneUtility::MaxVolume()

 	{

 	return iDevSound->MaxVolume();

 	}

 TInt CMMFMdaAudioToneUtility::Volume()

 	{

 	return iDevSound->Volume();

 	}

 void CMMFMdaAudioToneUtility::SetVolume(TInt aVolume) 

 	{

 	iDevSound->SetVolume(aVolume);

 	}

 void CMMFMdaAudioToneUtility::SetPriority(TInt aPriority, TInt aPref)

 	{

 	iPrioritySettings.iPref = aPref;

 	iPrioritySettings.iPriority = aPriority;

 	iDevSound->SetPrioritySettings(iPrioritySettings);

 	}

 void CMMFMdaAudioToneUtility::SetDTMFLengths(TTimeIntervalMicroSeconds32 aToneLength, 

 										 TTimeIntervalMicroSeconds32 aToneOffLength,

 										 TTimeIntervalMicroSeconds32 aPauseLength)

 	{

 	iDevSound->SetDTMFLengths(aToneLength, aToneOffLength, aPauseLength);

 	}

 void CMMFMdaAudioToneUtility::SetRepeats(TInt aRepeatNumberOfTimes, const TTimeIntervalMicroSeconds& aTrailingSilence)

 	{

 	iDevSound->SetToneRepeats(aRepeatNumberOfTimes, aTrailingSilence);

 	}

 void CMMFMdaAudioToneUtility::SetVolumeRamp(const TTimeIntervalMicroSeconds& aRampDuration)

 	{

 	iDevSound->SetVolumeRamp(aRampDuration);

 	}

 TInt CMMFMdaAudioToneUtility::FixedSequenceCount()

 	{

 	return iDevSound->FixedSequenceCount();

 	}

 const TDesC& CMMFMdaAudioToneUtility::FixedSequenceName(TInt aSequenceNumber)

 	{

 	return iDevSound->FixedSequenceName(aSequenceNumber);

 	}

 /**

 * CalculateBalance

 * @param aBalance

 * @param aLeft

 * @param aRight

 *

 * follows a simple straight line transformation

 * y = m x + c

 * m = (KMMFBalanceMaxLeft-KMMFBalanceMaxRight)/ 100 

 * c = KMMFBalanceMaxRight

 * by substitution

 * when aLeft = 0

 *   KMMFBalanceMaxRight = m * 0 + c

 *   c = KMMFBalanceMaxRight

 * when aLeft = 100

 * KMMFBalanceMaxLeft = m * 100 + KMMFBalanceMaxRight

 * m = ( KMMFBalanceMaxLeft - KMMFBalanceMaxRight ) /100

 */

 void CMMFMdaAudioToneUtility::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));

 	}

 /**

 * CalculateLeftRightBalance

 * @param aLeft

 * @param aRight

 * @param aBalance

 * Preconditions:

 * !(aBalance < KMMFBalanceMaxLeft || aBalance > KMMFBalanceMaxRight)

 * y = m x + c

 * aLeft = m ( aBalance ) + c

 * when aBalance = KMMFBalanceMaxLeft   aLeft = 100

 * when aBalance = KMMFBalanceMaxRight  aLeft = 0

 * 100 = m( KMMFBalanceMaxLeft ) + c

 * 0   = m( KMMFBalanceMaxRight ) + c 

 * c = -(KMMFBalanceMaxRight) m

 * 100 = m(KMMFBalanceMaxLeft ) - m(KMMFBalanceMaxRight)

 * m = 100/(KMMFBalanceMaxLeft - KMMFBalanceMaxRight )

 * c = -(KMMFBalanceMaxRight) * 100 /(KMMFBalanceMaxLeft - KMMFBalanceMaxRight )

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

 */

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

 	{

 	// [ assert precondition that aBalance is within limits ]

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

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

 	}

 void CMMFMdaAudioToneUtility::SetBalanceL(TInt aBalance) 

 	{

 	TInt left;

 	TInt right;

 	CalculateLeftRightBalance(left,right,aBalance);

 	iDevSound->SetPlayBalanceL(left,right);

 	}

 TInt CMMFMdaAudioToneUtility::GetBalanceL() 

 	{

 	TInt left;

 	TInt right;

 	TInt balance;

 	iDevSound->GetPlayBalanceL(left, right);

 	CalculateBalance(balance,left,right);

 	return balance; 

 	}

 void CMMFMdaAudioToneUtility::PrepareToPlayTone(TInt aFrequency, const TTimeIntervalMicroSeconds& aDuration)

 	{

 	delete iToneConfig;

 	iToneConfig = NULL;

 	TRAPD(error, iToneConfig = CMMFSimpleToneConfig::NewL(aFrequency, aDuration));

 	iAsyncCallback->MatoPrepareComplete(error);

 	}

 void CMMFMdaAudioToneUtility::PrepareToPlayDualTone(TInt aFrequencyOne, TInt aFrequencyTwo, const TTimeIntervalMicroSeconds& aDuration)

 	{

 	delete iToneConfig; 

 	iToneConfig = NULL;

 	TRAPD(error, iToneConfig = CMMFDualToneConfig::NewL(aFrequencyOne, aFrequencyTwo, aDuration));

 	iAsyncCallback->MatoPrepareComplete(error);

 	}

 void CMMFMdaAudioToneUtility::PrepareToPlayDTMFString(const TDesC& aDTMF)

 	{

 	delete iToneConfig;

 	iToneConfig = NULL;

 	TRAPD(error, iToneConfig = CMMFDTMFStringToneConfig::NewL(aDTMF));

 	iAsyncCallback->MatoPrepareComplete(error);

 	}

 void CMMFMdaAudioToneUtility::PrepareToPlayDesSequence(const TDesC8& aSequence)

 	{

 	delete iToneConfig;

 	iToneConfig = NULL;

 	TRAPD(error, iToneConfig = CMMFDesSeqToneConfig::NewL(aSequence));

 	iAsyncCallback->MatoPrepareComplete(error);

 	}

 void CMMFMdaAudioToneUtility::PrepareToPlayFileSequence(const TDesC& aFileName)

 	{

 	delete iToneConfig;

 	iToneConfig = NULL;

 	TRAPD(error, iToneConfig = CMMFFileSeqToneConfig::NewL(aFileName));

 	iAsyncCallback->MatoPrepareComplete(error);

 	}

 void CMMFMdaAudioToneUtility::PrepareToPlayFileSequence(RFile& aFileName)

 	{

 	delete iToneConfig;

 	iToneConfig = NULL;

 	TRAPD(error, iToneConfig = CMMFFileSeqToneConfig::NewL(aFileName));

 	iAsyncCallback->MatoPrepareComplete(error);

 	}

 void CMMFMdaAudioToneUtility::PrepareToPlayFixedSequence(TInt aSequenceNumber)

 	{

 	delete iToneConfig;

 	iToneConfig = NULL;

 	TRAPD(error, iToneConfig = CMMFFixedSeqToneConfig::NewL(aSequenceNumber));

 	iSequenceNumber = aSequenceNumber;

 	iAsyncCallback->MatoPrepareComplete(error);

 	}

 void CMMFMdaAudioToneUtility::CancelPrepare()

 	{

 	// xxx - do we need to cancel the callback?  What if the callback is actually calling back another error?  Probably best not to cancel...

 	delete iToneConfig;

 	iToneConfig = NULL;

 	if (iState == EMdaAudioToneUtilityPrepared)

 		{

 		iState = EMdaAudioToneUtilityNotReady;

 		}

 	// Cancel the AO

 	iAsyncCallback->Cancel();

 	}

 TInt CMMFMdaAudioToneUtility::Pause()

 	{

 	// Handle scenario when Pause is called before playback has started

 	if (iState != EMdaAudioToneUtilityPlaying || (iState == EMdaAudioToneUtilityPlaying && !iInitialized))

 		{

 		return KErrNotReady;

 		}

 	else if(! iDevSound->IsResumeSupported() || iToneConfig->Type() != CMMFToneConfig::EMmfToneTypeFileSeq)

 		{

 		return KErrNotSupported;

 		}

 	iDevSound->Pause();

 	iState = EMdaAudioToneUtilityPaused;

 	return KErrNone;

 	}

 TInt CMMFMdaAudioToneUtility::Resume()

 	{

 	TInt err = KErrNone;

 	if (iState != EMdaAudioToneUtilityPaused)

 		{

 		err = KErrNotReady;

 		}

 	else if( iDevSound->IsResumeSupported() == EFalse || iToneConfig->Type() != CMMFToneConfig::EMmfToneTypeFileSeq)

 		{

 		err = KErrNotSupported;

 		}

 	if(err == KErrNone)

 		{

 		err =  iDevSound->Resume();

 		if(err == KErrNone)

 			{

 			iState = EMdaAudioToneUtilityPlaying;

 			}

 		}

 	return err;

 	}

 void CMMFMdaAudioToneUtility::Play()

 	{

 	TInt error = KErrNone;

 	if ((iState == EMdaAudioToneUtilityPlaying) || (iState == EMdaAudioToneUtilityPaused) || iPlayCalled)

 		{

 		error = KErrInUse;

 		}

 	if (!error)

 		{

 		if (!iToneConfig)

 			{

 			TRAP(error, iToneConfig = CMMFFixedSeqToneConfig::NewL(iSequenceNumber));

 			}

 		}

 	// If there was an error, notify the client now.  Otherwise, client will be notified when

 	// play has finished.

 	if (error)

 		{

 		iState = EMdaAudioToneUtilityNotReady;

 		iAsyncCallback->MatoPlayComplete(error);

 		}

 	if (!error)

 		{

 		iState = EMdaAudioToneUtilityPlaying;

 		if (iInitialized)

 			{

 			// Play() is called after InitializeComplete()

 			if (iInitializeState)

 				{

 				// InitializeComplete() with error other than KErrNone

 				iState = EMdaAudioToneUtilityNotReady;

 				iAsyncCallback->MatoPlayComplete(iInitializeState);

 				}

 			else

 				{

 				PlayAfterInitialized();

 				}

 			}

 		else

 			{

 			// Play() is called before InitializeComplete()

 			iPlayCalled = ETrue;

 			}

 		}

 	}

 void CMMFMdaAudioToneUtility::PlayAfterInitialized()

 	{

 #ifdef _DEBUG

 	if (iInitialized == EFalse)

 		{

 		iPlayCalledBeforeInitialized = ETrue;

 		}

 #endif

 	TInt error = KErrNone;

 	switch (iToneConfig->Type())

 		{

 		case CMMFToneConfig::EMmfToneTypeSimple:

 			{

 			CMMFSimpleToneConfig* c = STATIC_CAST(CMMFSimpleToneConfig*, iToneConfig);

 			TRAP(error, iDevSound->PlayToneL(c->Frequency(), c->Duration()));

 			break;

 			}

 		case CMMFToneConfig::EMmfToneTypeDual:

 			{

 			CMMFDualToneConfig* c = STATIC_CAST(CMMFDualToneConfig*, iToneConfig);

 			TRAP(error, iDevSound->PlayDualToneL(c->FrequencyOne(), c->FrequencyTwo(), c->Duration()));

 			break;

 			}

 		case CMMFToneConfig::EMmfToneTypeDTMF:

 			{

 			CMMFDTMFStringToneConfig* c = STATIC_CAST(CMMFDTMFStringToneConfig*, iToneConfig);

 			TRAP(error, iDevSound->PlayDTMFStringL(c->DTMF()));

 			break;

 			}

 		case CMMFToneConfig::EMmfToneTypeDesSeq:

 			{

 			CMMFDesSeqToneConfig* c = STATIC_CAST(CMMFDesSeqToneConfig*, iToneConfig);

 			TRAP(error, iDevSound->PlayToneSequenceL(c->DesSeq()));

 			break;

 			}

 		case CMMFToneConfig::EMmfToneTypeFileSeq:

 			{

 			CMMFFileSeqToneConfig* c = STATIC_CAST(CMMFFileSeqToneConfig*, iToneConfig);

 			// check we have rights to play

 			TRAP(error, c->ExecuteIntentL());

 			// if we have rights then go ahead and play

 			if (error == KErrNone)

 				{

 				TRAP(error, iDevSound->PlayToneSequenceL(c->FileSeq()));

 				}

 			break;

 			}

 		case CMMFToneConfig::EMmfToneTypeFixedSeq:

 			{

 			CMMFFixedSeqToneConfig* c = STATIC_CAST(CMMFFixedSeqToneConfig*, iToneConfig);

 			TRAP(error, iDevSound->PlayFixedSequenceL(c->SequenceNumber()));

 			break;

 			}

 		default:

 			{	

 			User::Panic(KMMFMdaAudioToneUtilityPanicCategory, EMMFMdaAudioToneUtilityBadToneConfig);

 			break;

 			}

 		}

 	// If there was an error, notify the client now.  Otherwise, client will be notified when

 	// play has finished.

 	if (error)

 		{

 		iState = EMdaAudioToneUtilityNotReady;

 		iAsyncCallback->MatoPlayComplete(error);

 		}

 	else

 		{

         if(iPlayStartObserver)

             {

             iAsyncCallback->MatoPlayStarted(KErrNone);

             }

 		}

 	}

 void CMMFMdaAudioToneUtility::CancelPlay()

 	{

 	iDevSound->Stop();

 	if(iState == EMdaAudioToneUtilityPlaying || iState == EMdaAudioToneUtilityPaused)

 		{

 		iState = EMdaAudioToneUtilityPrepared;

 		}

 	// Cancel the AO

 	iAsyncCallback->Cancel();

 	iPlayCalled = EFalse;

 	}

 void CMMFMdaAudioToneUtility::SendEventToClient(const TMMFEvent& /*aEvent*/)

 	{

 	if(iState == EMdaAudioToneUtilityPlaying)

 		{

 		iState = EMdaAudioToneUtilityPrepared;

 		}

 	iAsyncCallback->MatoPlayComplete(KErrInUse);

 	}

 void CMMFMdaAudioToneUtility::RegisterPlayStartCallback(MMdaAudioTonePlayStartObserver& aObserver)

 	{

 	iPlayStartObserver = &aObserver;

 	}

 void CMMFMdaAudioToneUtility::MatoPrepareComplete(TInt aError)

 	{

 	if (!aError)

 		{

 		iState = EMdaAudioToneUtilityPrepared;

 		}

 	else 

 		{

 		iState = EMdaAudioToneUtilityNotReady;

 		}

 	iCallback.MatoPrepareComplete(aError);

 	}

 void CMMFMdaAudioToneUtility::MatoPlayComplete(TInt aError)

 	{

 	iState = EMdaAudioToneUtilityPrepared;

 	iCallback.MatoPlayComplete(aError);

 	}

 void CMMFMdaAudioToneUtility::MatoPlayStarted(TInt aError)

 	{

 	__ASSERT_DEBUG(aError==KErrNone, Panic(EPlayStartedCalledWithError));

 	// Not always there is an observer registered

 	if(iPlayStartObserver)

 		{

 		iPlayStartObserver->MatoPlayStarted(aError);

 		}

 	}

 // CustomInferface - just pass on to DevSound. 

 TAny* CMMFMdaAudioToneUtility::CustomInterface(TUid aInterfaceId)

 	{

 	return iDevSound->CustomInterface(aInterfaceId);

 	}

 CMMFMdaAudioToneObserverCallback* CMMFMdaAudioToneObserverCallback::NewL(MMdaAudioToneObserver& aCallback, MMdaAudioTonePlayStartObserver& aPlayStartCallback)

 	{

 	return new(ELeave) CMMFMdaAudioToneObserverCallback(aCallback, aPlayStartCallback);

 	}

 CMMFMdaAudioToneObserverCallback::CMMFMdaAudioToneObserverCallback(MMdaAudioToneObserver& aCallback, MMdaAudioTonePlayStartObserver& aPlayStartCallback) :

 	CActive(CActive::EPriorityHigh),

 	iCallback(aCallback),

 	iPlayStartCallback(aPlayStartCallback)

 	{

 	CActiveScheduler::Add(this);

 	}

 CMMFMdaAudioToneObserverCallback::~CMMFMdaAudioToneObserverCallback()

 	{

 	Cancel();

 	}

 void CMMFMdaAudioToneObserverCallback::MatoPrepareComplete(TInt aError)

 	{

 	if(!IsActive())

 	    {

         iAction = EPrepareComplete;

         iErrorCode = aError;

         TRequestStatus* s = &iStatus;

         SetActive();

         User::RequestComplete(s, KErrNone);

 	    }

 	else

 	    {

 		// Since the default granularity is 8, failing of Append() is unusual, hence ignoring the return err.

 	    iCallBackQueue.Append(EPrepareComplete);

 	    iCallBackQueueError.Append(aError);

 	    }

 	}

 void CMMFMdaAudioToneObserverCallback::MatoPlayComplete(TInt aError)

 	{

     if(!IsActive())

         {

         iAction = EPlayComplete;

         iErrorCode = aError;

         TRequestStatus* s = &iStatus;

         SetActive();

         User::RequestComplete(s, KErrNone);

         }

     else

         {

         iCallBackQueue.Append(EPlayComplete);

         iCallBackQueueError.Append(aError);

         }

 	}

 void CMMFMdaAudioToneObserverCallback::MatoPlayStarted(TInt aError)

 	{

     if(!IsActive())

         {

         iAction = EPlayStarted;

         iErrorCode = aError;

         TRequestStatus* s = &iStatus;

         SetActive();

         User::RequestComplete(s, KErrNone);

         }

     else

         {

         iCallBackQueue.Append(EPlayStarted);

         iCallBackQueueError.Append(aError);

         }

 	}

 void CMMFMdaAudioToneObserverCallback::RunL()

 	{

 	switch (iAction)

 		{

 		case EPrepareComplete:

 			{

 			iCallback.MatoPrepareComplete(iErrorCode);

 			break;

 			}

 		case EPlayComplete:

 			{

 			iCallback.MatoPlayComplete(iErrorCode);

 			break;

 			}

 		case EPlayStarted:

 			iPlayStartCallback.MatoPlayStarted(iErrorCode);

 			break;

 		}

 	if(iCallBackQueue.Count() > 0 & !IsActive() )

 	    {

         iAction = TMMFAudioToneObserverCallbackAction(iCallBackQueue[0]);

         iCallBackQueue.Remove(0);

         iErrorCode = iCallBackQueueError[0];

         iCallBackQueueError.Remove(0);

         TRequestStatus* s = &iStatus;

         User::RequestComplete(s, KErrNone);

         SetActive();

 	    }

 	}

 void CMMFMdaAudioToneObserverCallback::DoCancel()

 	{

 	//nothing to cancel

 	}

 // Tone config classes

 // Simple Tone

 CMMFToneConfig* CMMFSimpleToneConfig::NewL(TInt aFrequency, const TTimeIntervalMicroSeconds& aDuration)

 	{

 	return STATIC_CAST(CMMFToneConfig*, new(ELeave) CMMFSimpleToneConfig(aFrequency, aDuration));

 	}

 CMMFSimpleToneConfig::CMMFSimpleToneConfig(TInt aFrequency, const TTimeIntervalMicroSeconds& aDuration) :

 	CMMFToneConfig(CMMFToneConfig::EMmfToneTypeSimple),

 	iFrequency(aFrequency),

 	iDuration(aDuration)

 	{

 	}

 CMMFSimpleToneConfig::~CMMFSimpleToneConfig()

 	{

 	}

 TInt CMMFSimpleToneConfig::Frequency()

 	{

 	return iFrequency;

 	}

 const TTimeIntervalMicroSeconds& CMMFSimpleToneConfig::Duration()

 	{

 	return iDuration;

 	}

 // Dual Tone 

 CMMFToneConfig* CMMFDualToneConfig::NewL(TInt aFrequencyOne, TInt aFrequencyTwo, const TTimeIntervalMicroSeconds& aDuration)

 	{

 	return STATIC_CAST(CMMFToneConfig*, new(ELeave) CMMFDualToneConfig(aFrequencyOne, aFrequencyTwo, aDuration));

 	}

 CMMFDualToneConfig::CMMFDualToneConfig(TInt aFrequencyOne, TInt aFrequencyTwo, const TTimeIntervalMicroSeconds& aDuration) :

 	CMMFToneConfig(CMMFToneConfig::EMmfToneTypeDual),

 	iFrequencyOne(aFrequencyOne),

 	iFrequencyTwo(aFrequencyTwo),

 	iDuration(aDuration)

 	{

 	}

 CMMFDualToneConfig::~CMMFDualToneConfig()

 	{

 	}

 TInt CMMFDualToneConfig::FrequencyOne()

 	{

 	return iFrequencyOne;

 	}

 TInt CMMFDualToneConfig::FrequencyTwo()

 	{

 	return iFrequencyTwo;

 	}

 const TTimeIntervalMicroSeconds& CMMFDualToneConfig::Duration()

 	{

 	return iDuration;

 	}

 CMMFToneConfig* CMMFDTMFStringToneConfig::NewL(const TDesC& aDTMF)

 	{

 	CMMFDTMFStringToneConfig* s = new(ELeave) CMMFDTMFStringToneConfig;

 	CleanupStack::PushL(s);

 	s->ConstructL(aDTMF);

 	CleanupStack::Pop();

 	return STATIC_CAST(CMMFToneConfig*, s);

 	}

 CMMFDTMFStringToneConfig::CMMFDTMFStringToneConfig() :

 	CMMFToneConfig(CMMFToneConfig::EMmfToneTypeDTMF)

 	{

 	}

 LOCAL_C void validateDTMFL(const TDesC& aDTMF)

 //

 // Validate that the supplied DTMf string contains only playable characters

 // 

 	{

 	TInt stringLength = aDTMF.Length();

 	TChar ch;

 	for (TInt index = 0; index < stringLength ; index++)

 		{

 		ch = aDTMF[index];

 		if (!ch.IsDigit() && !ch.IsHexDigit() && !ch.IsSpace() &&

 			(ch != '*') && (ch != '#') && (ch != ','))

 			{

 			User::Leave(KErrArgument); // Bad DTMF string

 			}

 		}

 	}

 void CMMFDTMFStringToneConfig::ConstructL(const TDesC& aDTMF)

 	{

 	validateDTMFL(aDTMF);

 	iDTMF = aDTMF.AllocL();

 	}

 CMMFDTMFStringToneConfig::~CMMFDTMFStringToneConfig()

 	{

 	delete iDTMF;

 	}

 const TDesC& CMMFDTMFStringToneConfig::DTMF()

 	{

 	return *iDTMF;

 	}

 CMMFToneConfig* CMMFDesSeqToneConfig::NewL(const TDesC8& aDesSeq)

 	{

 	CMMFDesSeqToneConfig* s = new(ELeave) CMMFDesSeqToneConfig;

 	CleanupStack::PushL(s);

 	s->ConstructL(aDesSeq);

 	CleanupStack::Pop();

 	return STATIC_CAST(CMMFToneConfig*, s);

 	}

 CMMFDesSeqToneConfig::CMMFDesSeqToneConfig() :

 	CMMFToneConfig(CMMFToneConfig::EMmfToneTypeDesSeq)

 	{

 	}

 void CMMFDesSeqToneConfig::ConstructL(const TDesC8& aDesSeq)

 	{

 	iDesSeq = aDesSeq.AllocL();

 	}

 CMMFDesSeqToneConfig::~CMMFDesSeqToneConfig()

 	{

 	delete iDesSeq;

 	}

 const TDesC8& CMMFDesSeqToneConfig::DesSeq()

 	{

 	return *iDesSeq;

 	}

 CMMFToneConfig* CMMFFileSeqToneConfig::NewL(const TDesC& aFileSeq)

 	{

 	CMMFFileSeqToneConfig* s = new(ELeave) CMMFFileSeqToneConfig;

 	CleanupStack::PushL(s);

 	s->ConstructL(aFileSeq);

 	CleanupStack::Pop();

 	return STATIC_CAST(CMMFToneConfig*, s);

 	}

 CMMFFileSeqToneConfig::CMMFFileSeqToneConfig() :

 	CMMFToneConfig(CMMFToneConfig::EMmfToneTypeFileSeq)

 	{

 	}

 void CMMFFileSeqToneConfig::ConstructL(const TDesC& aFileSeq)

 	{

 	// get access to DRM content through filename

 	iCAFContent = CContent::NewL(aFileSeq);

 	// open the CAF source with play intent

 	iCAFData = iCAFContent->OpenContentL(ContentAccess::EPlay, KDefaultContentObject);

 	// read into a descriptor

 	TInt dataSize = 0;

 	iCAFData->DataSizeL(dataSize);

 	iDesSeq = HBufC8::NewL(dataSize);

 	TPtr8 desSeqPtr = iDesSeq->Des();

 	iCAFData->Read(desSeqPtr);	

 	}

 CMMFToneConfig* CMMFFileSeqToneConfig::NewL(RFile& aFile)

 	{

 	CMMFFileSeqToneConfig* s = new(ELeave) CMMFFileSeqToneConfig;

 	CleanupStack::PushL(s);

 	s->ConstructL(aFile);

 	CleanupStack::Pop();

 	return STATIC_CAST(CMMFToneConfig*, s);

 	}

 void CMMFFileSeqToneConfig::ConstructL(RFile& aFile)

 	{

 	// get DRM access to file handle

 	iCAFContent = CContent::NewL(aFile);

 	// open the CAF source with play intent

 	iCAFData = iCAFContent->OpenContentL(ContentAccess::EPlay, KDefaultContentObject);

 	// read into a descriptor

 	TInt dataSize = 0;

 	iCAFData->DataSizeL(dataSize);

 	iDesSeq = HBufC8::NewL(dataSize);

 	TPtr8 desSeqPtr = iDesSeq->Des();

 	iCAFData->Read(desSeqPtr);	

 	}

 CMMFFileSeqToneConfig::~CMMFFileSeqToneConfig()

 	{

 	delete iCAFData;

 	iCAFData = NULL;

 	delete iCAFContent;

 	iCAFContent = NULL;

 	delete iDesSeq;

 	}

 const TDesC8& CMMFFileSeqToneConfig::FileSeq()

 	{

 	return *iDesSeq;

 	}

 void CMMFFileSeqToneConfig::ExecuteIntentL()

 	{

 	if (iCAFData)

 		{

 		User::LeaveIfError(iCAFData->ExecuteIntent(ContentAccess::EPlay));

 		}

 	}

 CMMFToneConfig* CMMFFixedSeqToneConfig::NewL(TInt aSeqNo)

 	{

 	return STATIC_CAST(CMMFToneConfig*, new(ELeave) CMMFFixedSeqToneConfig(aSeqNo));

 	}

 CMMFFixedSeqToneConfig::CMMFFixedSeqToneConfig(TInt aSeqNo) :

 	CMMFToneConfig(CMMFToneConfig::EMmfToneTypeFixedSeq),

 	iSequenceNumber(aSeqNo)

 	{

 	}

 CMMFFixedSeqToneConfig::~CMMFFixedSeqToneConfig()

 	{

 	}

 TInt CMMFFixedSeqToneConfig::SequenceNumber()

 	{

 	return iSequenceNumber;

 	}