multimediacommscontroller/tsrc/mmfstub/src/SoundDevice_STUB.cpp
changeset 0 1bce908db942
equal deleted inserted replaced
-1:000000000000 0:1bce908db942
       
     1 /*
       
     2 * Copyright (c) 2001-2006 Nokia Corporation and/or its subsidiary(-ies).
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description:  
       
    15 *
       
    16 */
       
    17 
       
    18 
       
    19 
       
    20 
       
    21 #include <Mmf/Server/SoundDevice.h>
       
    22 
       
    23 /*
       
    24  *
       
    25  *	Default Constructor.
       
    26  *
       
    27  *
       
    28  */
       
    29 CMMFDevSound::CMMFDevSound()
       
    30 	{
       
    31 	}
       
    32 
       
    33 /*
       
    34  *  -doxygen comments moved to header-
       
    35  *
       
    36  *	Destructor.
       
    37  *
       
    38  *	Deletes all objects and releases all resource owned by this
       
    39  *	instance.
       
    40  *
       
    41  */
       
    42 EXPORT_C CMMFDevSound::~CMMFDevSound()
       
    43 	{
       
    44 	}
       
    45 
       
    46 /*
       
    47  *  -doxygen comments moved to header-
       
    48  *
       
    49  *	Constructs, and returns a pointer to, a new CMMFDevSound object.
       
    50  *
       
    51  *	Leaves on failure.
       
    52  *
       
    53  */
       
    54 EXPORT_C CMMFDevSound* CMMFDevSound::NewL()
       
    55 	{
       
    56 	CMMFDevSound* self = new (ELeave) CMMFDevSound;
       
    57 	CleanupStack::PushL(self);
       
    58 	self->ConstructL();
       
    59 	CleanupStack::Pop();
       
    60 	return self;
       
    61 	}
       
    62 
       
    63 /*
       
    64  *  -doxygen comments moved to header-
       
    65  *
       
    66  *	Second phase constructor.
       
    67  *
       
    68  */
       
    69 void CMMFDevSound::ConstructL()
       
    70 	{
       
    71 	}
       
    72 
       
    73 /*
       
    74  *  -doxygen comments moved to header-
       
    75  *
       
    76  *	Initializes CMMFDevSound object to play and record PCM16 raw audio data
       
    77  *	with sampling rate of 8 KHz.
       
    78  *
       
    79  *	On completion of Initialization, calls InitializeComplete() on
       
    80  *	aDevSoundObserver.
       
    81  *
       
    82  *	Leaves on failure.
       
    83  *
       
    84  *	@param	"aDevSoundObserver"
       
    85  *			A reference to DevSound Observer instance.
       
    86  *
       
    87  *	@param	"aMode"
       
    88  *			Mode for which this object will be used.
       
    89  *
       
    90  */
       
    91 EXPORT_C void CMMFDevSound::InitializeL(MDevSoundObserver& aDevSoundObserver, TMMFState aMode)
       
    92 
       
    93 	{
       
    94 	}
       
    95 
       
    96 /*
       
    97  *  -doxygen comments moved to header-
       
    98  *
       
    99  *	Initializes DevSound object for the mode aMode for processing audio data
       
   100  *	with hardware device aHWDev.
       
   101  *
       
   102  *	On completion of Initialization, the observer will be notified via call back
       
   103  *	InitializeComplete().
       
   104  *
       
   105  *	Leaves on failure.
       
   106  *
       
   107  *	@param	"aDevSoundObserver"
       
   108  *			A reference to DevSound Observer instance.
       
   109  *
       
   110  *	@param	"aHWDev"
       
   111  *			CMMFHwDevice implementation identifier.
       
   112  *
       
   113  *	@param	"aMode"
       
   114  *			Mode for which this object will be used.
       
   115  *
       
   116  */
       
   117 EXPORT_C void CMMFDevSound::InitializeL(MDevSoundObserver& aDevSoundObserver, TUid aHWDev, TMMFState aMode)
       
   118 	{
       
   119 	}
       
   120 
       
   121 /*
       
   122  *  -doxygen comments moved to header-
       
   123  *
       
   124  *	Initializes DevSound object for the mode aMode for processing audio data
       
   125  *	with hardware device supporting FourCC aDesiredFourCC.
       
   126  *
       
   127  *	On completion of Initialization, the observer will be notified via call back
       
   128  *	InitializeComplete().
       
   129  *
       
   130  *	Leaves on failure.
       
   131  *
       
   132  *	@param	"aDevSoundObserver"
       
   133  *			A reference to DevSound Observer instance.
       
   134  *
       
   135  *	@param	"aDesiredFourCC"
       
   136  *			CMMFHwDevice implementation FourCC.
       
   137  *
       
   138  *	@param	"aMode"
       
   139  *			Mode for which this object will be used.
       
   140  *
       
   141  */
       
   142 EXPORT_C void CMMFDevSound::InitializeL(MDevSoundObserver& aDevSoundObserver, 
       
   143 										  TFourCC aDesiredFourCC, TMMFState aMode)
       
   144 	{
       
   145 	}
       
   146 
       
   147 /*
       
   148  *  -doxygen comments moved to header-
       
   149  *
       
   150  *	Returns the supported Audio settings.
       
   151  *
       
   152  *	@return	"TMMFCapabilities"
       
   153  *			Device settings.
       
   154  *
       
   155  */
       
   156 EXPORT_C TMMFCapabilities CMMFDevSound::Capabilities()
       
   157 	{
       
   158 	return TMMFCapabilities();
       
   159 	}
       
   160 
       
   161 /*
       
   162  *  -doxygen comments moved to header-
       
   163  *
       
   164  *	Returns the current audio settings.
       
   165  *
       
   166  *	@return	"TMMFCapabilities"
       
   167  *			Device settings.
       
   168  *
       
   169  */
       
   170 EXPORT_C TMMFCapabilities CMMFDevSound::Config() const
       
   171 	{
       
   172 	return TMMFCapabilities();
       
   173 	}
       
   174 
       
   175 /*
       
   176  *  -doxygen comments moved to header-
       
   177  *
       
   178  *	Configure CMMFDevSound object for the settings in aConfig.
       
   179  *
       
   180  *	Use this to set sampling rate, Encoding and Mono/Stereo.
       
   181  *
       
   182  *	@param	"aConfig"
       
   183  *			Attribute values to which CMMFDevSound object will be configured to.
       
   184  *
       
   185  */
       
   186 EXPORT_C void CMMFDevSound::SetConfigL(const TMMFCapabilities& aConfig)
       
   187 	{
       
   188 	}
       
   189 
       
   190 /*
       
   191  *  -doxygen comments moved to header-
       
   192  *
       
   193  *	Returns an integer representing the maximum volume.
       
   194  *
       
   195  *	This is the maximum value which can be passed to CMMFDevSound::SetVolume.
       
   196  *
       
   197  *	@return	"TInt"
       
   198  *			The maximum volume. This value is platform dependent but is always
       
   199  *			greater than or equal to one.
       
   200  *
       
   201  */
       
   202 EXPORT_C TInt CMMFDevSound::MaxVolume()
       
   203 	{
       
   204 	return 100;
       
   205 	}
       
   206 
       
   207 /*
       
   208  *  -doxygen comments moved to header-
       
   209  *
       
   210  *	Returns an integer representing the current volume.
       
   211  *
       
   212  *	@return	"TInt"
       
   213  *			The current volume level.
       
   214  *
       
   215  */
       
   216 EXPORT_C TInt CMMFDevSound::Volume()
       
   217 	{
       
   218 	return 50;
       
   219 	}
       
   220 
       
   221 /*
       
   222  *  -doxygen comments moved to header-
       
   223  *
       
   224  *	Changes the current playback volume to a specified value.
       
   225  *
       
   226  *	The volume can be changed before or during playback and is effective
       
   227  *	immediately.
       
   228  *
       
   229  *	@param	"aVolume"
       
   230  *			The volume setting. This can be any value from zero to the value
       
   231  *			returned by a call to CMMFDevSound::MaxVolume(). If the
       
   232  *			volume is not within this range, the volume is automatically set to
       
   233  *			minimum or maximum value based on the value that is being passed.
       
   234  *			Setting a zero value mutes the sound. Setting the maximum value
       
   235  *			results in the loudest possible sound.
       
   236  *
       
   237  */
       
   238 EXPORT_C void CMMFDevSound::SetVolume(TInt aVolume)
       
   239 	{
       
   240 	}
       
   241 
       
   242 /*
       
   243  *  -doxygen comments moved to header-
       
   244  *
       
   245  *	Returns an integer representing the maximum gain.
       
   246  *
       
   247  *	This is the maximum value which can be passed to CMMFDevSound::SetGain.
       
   248  *
       
   249  *	@return	"TInt"
       
   250  *			The maximum gain. This value is platform dependent but is always
       
   251  *			greater than or equal to one.
       
   252  *
       
   253  */
       
   254 EXPORT_C TInt CMMFDevSound::MaxGain()
       
   255 	{
       
   256 	return 100;
       
   257 	}
       
   258 
       
   259 /*
       
   260  *  -doxygen comments moved to header-
       
   261  *
       
   262  *	Returns an integer representing the current gain.
       
   263  *
       
   264  *	@return	"TInt"
       
   265  *			The current gain level.
       
   266  *
       
   267  */
       
   268 EXPORT_C TInt CMMFDevSound::Gain()
       
   269 	{
       
   270 	return 50;
       
   271 	}
       
   272 
       
   273 /*
       
   274  *  -doxygen comments moved to header-
       
   275  *
       
   276  *	Changes the current recording gain to a specified value.
       
   277  *
       
   278  *	The gain can be changed before or during recording and is effective
       
   279  *	immediately.
       
   280  *
       
   281  *	@param	"TInt aGain"
       
   282  *			The gain setting. This can be any value from zero to the value
       
   283  *			returned by a call to CMMFDevSound::MaxGain(). If the
       
   284  *			volume is not within this range, the gain is automatically set to
       
   285  *			minimum or maximum value based on the value that is being passed.
       
   286  *			Setting a zero value mutes the sound. Setting the maximum value
       
   287  *			results in the loudest possible sound.
       
   288  *
       
   289  */
       
   290 EXPORT_C void CMMFDevSound::SetGain(TInt aGain)
       
   291 	{
       
   292 	}
       
   293 
       
   294 /*
       
   295  *  -doxygen comments moved to header-
       
   296  *
       
   297  *	Returns the speaker balance set for playing.
       
   298  *
       
   299  *	Leaves on failure.
       
   300  *
       
   301  *	@param	"aLeftPrecentage"
       
   302  *			On return contains the left speaker volume percentage.
       
   303  *
       
   304  *	@param	"aRightPercentage"
       
   305  *			On return contains the right speaker volume percentage.
       
   306  *
       
   307  */
       
   308 EXPORT_C void CMMFDevSound::GetPlayBalanceL(TInt& aLeftPercentage, TInt& aRightPercentage)
       
   309 	{
       
   310 	aLeftPercentage = 50;
       
   311 	aRightPercentage = 50;
       
   312 	}
       
   313 
       
   314 /*
       
   315  *  -doxygen comments moved to header-
       
   316  *
       
   317  *	Sets the speaker balance for playing.
       
   318  *
       
   319  *	The speaker balance can be changed before or during playback and is
       
   320  *	effective immediately.
       
   321  *
       
   322  *	@param	"aLeftPercentage"
       
   323  *			On return contains left speaker volume perecentage. This can be any
       
   324  *			value from zero to 100. Setting a zero value mutes the sound on left
       
   325  *			speaker.
       
   326  *
       
   327  *	@param	"aRightPercentage"
       
   328  *			On return contains right speaker volume perecentage. This can be any
       
   329  *			value from zero to 100. Setting a zero value mutes the sound on
       
   330  *			right speaker.
       
   331  *
       
   332  */
       
   333 EXPORT_C void CMMFDevSound::SetPlayBalanceL(TInt aLeftPercentage, TInt aRightPercentage)
       
   334 	{
       
   335 	}
       
   336 
       
   337 /*
       
   338  *  -doxygen comments moved to header-
       
   339  *
       
   340  *	Returns the microphone gain balance set for recording.
       
   341  *
       
   342  *	Leaves on failure.
       
   343  *
       
   344  *	@param	"aLeftPercentage"
       
   345  *			On return contains the left microphone gain percentage.
       
   346  *
       
   347  *	@param	"aRightPercentage"
       
   348  *			On return contains the right microphone gain percentage.
       
   349  *
       
   350  */
       
   351 EXPORT_C void CMMFDevSound::GetRecordBalanceL(TInt& aLeftPercentage, TInt& aRightPercentage)
       
   352 	{
       
   353 	}
       
   354 
       
   355 /*
       
   356  *  -doxygen comments moved to header-
       
   357  *
       
   358  *	Sets the microphone gain balance for recording.
       
   359  *
       
   360  *	The microphone gain balance can be changed before or during recording and
       
   361  *	is effective immediately.
       
   362  *
       
   363  *	@param	"aLeftPercentage"
       
   364  *			Left microphone gain precentage. This can be any value from zero to
       
   365  *			100. Setting a zero value mutes the gain on left microphone.
       
   366  *
       
   367  *	@param	"aRightPercentage"
       
   368  *			Right microphone gain precentage. This can be any value from zero to
       
   369  *			100. Setting a zero value mutes the gain on right microphone.
       
   370  *
       
   371  */
       
   372 EXPORT_C void CMMFDevSound::SetRecordBalanceL(TInt aLeftPercentage, TInt aRightPercentage)
       
   373 	{
       
   374 	}
       
   375 
       
   376 /*
       
   377  *  -doxygen comments moved to header-
       
   378  *
       
   379  *	Initializes audio device and start play process. This method queries and
       
   380  *	acquires the audio policy before initializing audio device. If there was an
       
   381  *	error during policy initialization, PlayError() method will be called on
       
   382  *	the observer with error code KErrAccessDenied, otherwise BufferToBeFilled()
       
   383  *	method will be called with a buffer reference. After reading data into the
       
   384  *	buffer reference passed, the client should call PlayData() to play data.
       
   385  *
       
   386  *	The amount of data that can be played is specified in
       
   387  *	CMMFBuffer::RequestSize(). Any data that is read into buffer beyond this
       
   388  *	size will be ignored.
       
   389  *
       
   390  *	Leaves on failure.
       
   391  *
       
   392  */
       
   393 EXPORT_C void CMMFDevSound::PlayInitL()
       
   394 	{
       
   395 	}
       
   396 
       
   397 /*
       
   398  *  -doxygen comments moved to header-
       
   399  *
       
   400  *	Initializes audio device and start record process. This method queries and
       
   401  *	acquires the audio policy before initializing audio device. If there was an
       
   402  *	error during policy initialization, RecordError() method will be called on
       
   403  *	the observer with error code KErrAccessDenied, otherwise BufferToBeEmptied()
       
   404  *	method will be called with a buffer reference. This buffer contains recorded
       
   405  *	or encoded data. After processing data in the buffer reference passed, the
       
   406  *	client should call RecordData() to continue recording process.
       
   407  *
       
   408  *	The amount of data that is available is specified in
       
   409  *	CMMFBuffer::RequestSize().
       
   410  *
       
   411  *	Leaves on failure.
       
   412  *
       
   413  */
       
   414 EXPORT_C void CMMFDevSound::RecordInitL()
       
   415 	{
       
   416 	}
       
   417 
       
   418 /*
       
   419  *  -doxygen comments moved to header-
       
   420  *
       
   421  *	Plays data in the buffer at the current volume. The client should fill
       
   422  *	the buffer with audio data before calling this method. The Observer gets
       
   423  *	reference to buffer along with callback BufferToBeFilled(). When playing of
       
   424  *	the audio sample is complete, successfully or otherwise, the method
       
   425  *	PlayError() on observer is called.
       
   426  *
       
   427  */
       
   428 EXPORT_C void CMMFDevSound::PlayData()
       
   429 	{
       
   430 	}
       
   431 
       
   432 /*
       
   433  *  -doxygen comments moved to header-
       
   434  *
       
   435  *	Contine the process of recording. Once the buffer is filled with recorded
       
   436  *	data, the Observer gets reference to buffer along with callback
       
   437  *	BufferToBeEmptied(). After processing the buffer (copying over to a
       
   438  *	different buffer or writing to file) the client should call this
       
   439  *	method to continue recording process.
       
   440  *
       
   441  */
       
   442 EXPORT_C void CMMFDevSound::RecordData()
       
   443 	{
       
   444 	}
       
   445 
       
   446 /*
       
   447  *  -doxygen comments moved to header-
       
   448  *
       
   449  *	Stops the ongoing operation (Play, Record, TonePlay, Convert)
       
   450  *
       
   451  */
       
   452 EXPORT_C void CMMFDevSound::Stop()
       
   453 	{
       
   454 	}
       
   455 
       
   456 /*
       
   457  *  -doxygen comments moved to header-
       
   458  *
       
   459  *	Temporarily Stops the ongoing operation (Play, Record, TonePlay, Convert)
       
   460  *
       
   461  */
       
   462 EXPORT_C void CMMFDevSound::Pause()
       
   463 	{
       
   464 	}
       
   465 
       
   466 /*
       
   467  *  -doxygen comments moved to header-
       
   468  *
       
   469  *	Returns the sample recorded so far.
       
   470  *
       
   471  *	@return "TInt"
       
   472  *			Returns the samples recorded.
       
   473  *
       
   474  */
       
   475 EXPORT_C TInt CMMFDevSound::SamplesRecorded()
       
   476 	{ 
       
   477 	return 10;
       
   478 	}
       
   479 
       
   480 /*
       
   481  *  -doxygen comments moved to header-
       
   482  *
       
   483  *	Returns the sample played so far.
       
   484  *
       
   485  *	@return "TInt"
       
   486  *			Returns the samples recorded.
       
   487  *
       
   488  */
       
   489 EXPORT_C TInt CMMFDevSound::SamplesPlayed()
       
   490 	{ 
       
   491 	return 10;
       
   492 	}
       
   493 
       
   494 
       
   495 /*
       
   496  *  -doxygen comments moved to header-
       
   497  *
       
   498  *	Initializes audio device and start playing tone. Tone is played with
       
   499  *	frequency and for duration specified.
       
   500  *
       
   501  *	Leaves on failure.
       
   502  *
       
   503  *	@param	"aFrequency"
       
   504  *			Frequency at with the tone will be played.
       
   505  *
       
   506  *	@param	"aDuration"
       
   507  *			The period over which the tone will be played. A zero value causes
       
   508  *			the no tone to be played (Verify this with test app).
       
   509  *
       
   510  */
       
   511 EXPORT_C void CMMFDevSound::PlayToneL(TInt aFrequency, const TTimeIntervalMicroSeconds& aDuration)
       
   512 	{
       
   513 	}
       
   514 
       
   515 /*
       
   516  *  -doxygen comments moved to header-
       
   517  *
       
   518  *	Initializes audio device and start playing a dual tone. 
       
   519  *  The tone consists of two sine waves of different frequencies summed together
       
   520  *  Dual Tone is played with specified frequencies and for specified duration.
       
   521  *
       
   522  *	@param	"aFrequencyOne"
       
   523  *			First frequency of dual tone
       
   524  *
       
   525  *	@param	"aFrequencyTwo"
       
   526  *			Second frequency of dual tone
       
   527  *
       
   528  *	@param	"aDuration"
       
   529  *			The period over which the tone will be played. A zero value causes
       
   530  *			the no tone to be played (Verify this with test app).
       
   531  */
       
   532 EXPORT_C void CMMFDevSound::PlayDualToneL(TInt aFrequencyOne, TInt aFrequencyTwo, const TTimeIntervalMicroSeconds& aDuration)
       
   533 	{
       
   534 	}
       
   535 
       
   536 /*
       
   537  *  -doxygen comments moved to header-
       
   538  *
       
   539  *	Initializes audio device and start playing DTMF string aDTMFString.
       
   540  *
       
   541  *	Leaves on failure.
       
   542  *
       
   543  *	@param	"aDTMFString"
       
   544  *			DTMF sequence in a descriptor.
       
   545  *
       
   546  */
       
   547 EXPORT_C void CMMFDevSound::PlayDTMFStringL(const TDesC& aDTMFString)
       
   548 	{
       
   549 	}
       
   550 
       
   551 /*
       
   552  *  -doxygen comments moved to header-
       
   553  *
       
   554  *	Initializes audio device and start playing tone sequence.
       
   555  *
       
   556  *	Leaves on failure.
       
   557  *
       
   558  *	@param	"TDesC8& aData"
       
   559  *			Tone sequence in a descriptor.
       
   560  *
       
   561  */
       
   562 EXPORT_C void CMMFDevSound::PlayToneSequenceL(const TDesC8& aData)
       
   563 	{
       
   564 	}
       
   565 
       
   566 /*
       
   567  *  -doxygen comments moved to header-
       
   568  *
       
   569  *	Initializes audio device and start playing the specified pre-defined tone
       
   570  *	sequence.
       
   571  *
       
   572  *	Leaves on failure.
       
   573  *
       
   574  *	@param	"aSequenceNumber"
       
   575  *			The index identifying the specific pre-defined tone sequence. Index
       
   576  *			values are relative to zero.
       
   577  *			This can be any value from zero to the value returned by a call to
       
   578  *			FixedSequenceCount() - 1.
       
   579  *			The function raises a panic if sequence number is not within this
       
   580  *			range.
       
   581  *	@see	FixedSequenceCount()
       
   582  *
       
   583  */
       
   584 EXPORT_C void CMMFDevSound::PlayFixedSequenceL(TInt aSequenceNumber)
       
   585 	{
       
   586 	}
       
   587 
       
   588 /*
       
   589  *  -doxygen comments moved to header-
       
   590  *
       
   591  *	Defines the number of times the audio is to be repeated during the tone
       
   592  *	playback operation.
       
   593  *
       
   594  *	A period of silence can follow each playing of tone. The tone playing can
       
   595  *	be repeated indefinitely.
       
   596  *
       
   597  *	@param	" aRepeatCount"
       
   598  *			The number of times the tone, together with the trailing silence,
       
   599  *			is to be repeated. If this is set to KMdaRepeatForever, then the
       
   600  *			tone, together with the trailing silence, is repeated indefinitely
       
   601  *			or until Stop() is called. If this is set to zero, then the tone is
       
   602  *			not repeated.
       
   603  *
       
   604  *			Supported only during tone playing.
       
   605  *
       
   606  */
       
   607 EXPORT_C void CMMFDevSound::SetToneRepeats(TInt aRepeatCount,
       
   608 				const TTimeIntervalMicroSeconds& aRepeatTrailingSilence)
       
   609 	{
       
   610 	}
       
   611 
       
   612 /*
       
   613  *  -doxygen comments moved to header-
       
   614  *
       
   615  *	Defines the duration of tone on, tone off and tone pause to be used during the
       
   616  *	DTMF tone playback operation.
       
   617  *
       
   618  *	Supported only during tone playing.
       
   619  *
       
   620  *	@param	"aToneOnLength"
       
   621  *			The period over which the tone will be played. If this is set to
       
   622  *			zero, then the tone is not played.
       
   623  *
       
   624  *	@param	"aToneOffLength"
       
   625  *			The period over which the no tone will be played.
       
   626  *
       
   627  *	@param	"aPauseLength"
       
   628  *			The period over which the tone playing will be paused.
       
   629  *
       
   630  */
       
   631 EXPORT_C void CMMFDevSound::SetDTMFLengths(TTimeIntervalMicroSeconds32& aToneOnLength,
       
   632 								TTimeIntervalMicroSeconds32& aToneOffLength,
       
   633 								TTimeIntervalMicroSeconds32& aPauseLength) 
       
   634 	{
       
   635 	}
       
   636 
       
   637 /*
       
   638  *  -doxygen comments moved to header-
       
   639  *
       
   640  *	Defines the period over which the volume level is to rise smoothly from
       
   641  *	nothing to the normal volume level.
       
   642  *
       
   643  *	@param	"aRampDuration"
       
   644  *			The period over which the volume is to rise. A zero value causes 
       
   645  *			the tone sample to be played at the normal level for the full
       
   646  *			duration of the playback. A value, which is longer than the duration
       
   647  *			of the tone sample, that the sample never reaches its normal
       
   648  *			volume level.
       
   649  *
       
   650  *
       
   651  */
       
   652 EXPORT_C void CMMFDevSound::SetVolumeRamp(const TTimeIntervalMicroSeconds& aRampDuration)
       
   653 	{	
       
   654 	}
       
   655 
       
   656 /*
       
   657  *  -doxygen comments moved to header-
       
   658  *
       
   659  *	Defines the priority settings that should be used for this instance.
       
   660  *
       
   661  *	@param	"aPrioritySettings"
       
   662  *			An class type representing the client's priority, priority 
       
   663  *			preference and state.
       
   664  *
       
   665  */
       
   666 EXPORT_C void CMMFDevSound::SetPrioritySettings(const TMMFPrioritySettings& aPrioritySettings)
       
   667 	{
       
   668 	}
       
   669 
       
   670 EXPORT_C TAny* CMMFDevSound::CustomInterface(TUid aInterface)
       
   671 	{
       
   672 	return NULL;
       
   673 	}
       
   674 
       
   675 /*
       
   676  *  -doxygen comments moved to header-
       
   677  *
       
   678  *	Returns the number of available pre-defined tone sequences.
       
   679  *
       
   680  *	This is the number of fixed sequence supported by DevSound by default.
       
   681  *
       
   682  *	@return	"TInt"
       
   683  *			The fixed sequence count. This value is implementation dependent
       
   684  *			but is always greater than or equal to zero.
       
   685  *
       
   686  */
       
   687 EXPORT_C TInt CMMFDevSound::FixedSequenceCount()
       
   688 	{
       
   689 	return 0;
       
   690 	}
       
   691 
       
   692 /*
       
   693  *  -doxygen comments moved to header-
       
   694  *
       
   695  *	Returns the name assigned to a specific pre-defined tone sequence.
       
   696  *
       
   697  *	This is the number of fixed sequence supported by DevSound by default.
       
   698  *
       
   699  *	The function raises a panic if sequence number specified invalid.
       
   700  *
       
   701  *	@return	"TDesC&"
       
   702  *			A reference to a Descriptor containing the fixed sequence
       
   703  *			name indexed by aSequenceNumber.
       
   704  *
       
   705  *	@param	"aSequenceNumber"
       
   706  *			The index identifying the specific pre-defined tone sequence. Index
       
   707  *			values are relative to zero.
       
   708  *			This can be any value from zero to the value returned by a call to
       
   709  *			FixedSequenceCount() - 1.
       
   710  *			The function raises a panic if sequence number is not within this
       
   711  *			range.
       
   712  *
       
   713  *	@see	FixedSequenceCount()
       
   714  *
       
   715  */
       
   716 EXPORT_C const TDesC& CMMFDevSound::FixedSequenceName(TInt aSequenceNumber)
       
   717 	{
       
   718 	return KNullDesC;
       
   719 	}
       
   720 
       
   721 
       
   722 /*
       
   723  *  -doxygen comments in header-
       
   724  */
       
   725 EXPORT_C void CMMFDevSound::GetSupportedInputDataTypesL(RArray<TFourCC>& aSupportedDataTypes,const TMMFPrioritySettings& aPrioritySettings) const
       
   726 	{
       
   727 	}
       
   728 
       
   729 
       
   730 /*
       
   731  *  -doxygen comments in header-
       
   732  */
       
   733 EXPORT_C void CMMFDevSound::GetSupportedOutputDataTypesL(RArray<TFourCC>& aSupportedDataTypes, const TMMFPrioritySettings& aPrioritySettings) const
       
   734 	{
       
   735 	}
       
   736 
       
   737