1 // Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #include <bautils.h>

    17 #include <utf.h>

    18 #include <mmf/common/mmfpaniccodes.h>

    19 #include "mmfclientaudioplayer.h"

    20 #include "mmfclientutility.h"

    21 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

    22 #include <mmf/common/mmfdurationinfocustomcommandsimpl.h>

    23 #include <mmf/common/mmfdurationinfocustomcommandsenums.h>

    24 #endif

    25 

    26 using namespace ContentAccess;

    27 

    28 // declared in the recorder module

    29 void Panic(TInt aPanicCode);

    30 

    31 void TMMFMessage::Complete(TInt aReason)

    32 	{

    33 	iMessage.Complete(aReason);

    34 	iAmCompleted = ETrue;

    35 	}

    36 

    37 /**

    38 Constructs and initialises a new instance of the audio player utility.

    39 

    40 The function leaves if the audio player utility object cannot be created.

    41 

    42 No callback notification is made upon completion of NewL().

    43 

    44 @param  aCallback

    45         The audio player observer interface.

    46 @param  aPriority

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

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

    49 @param  aPref

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

    51         EMdaPriorityPreferenceNone. Further values are given by TMdaPriorityPreference, and additional 

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

    53         portable code.

    54 

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

    56 

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

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

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

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

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

    62 */

    63 EXPORT_C CMdaAudioPlayerUtility* CMdaAudioPlayerUtility::NewL(MMdaAudioPlayerCallback& aCallback,

    64 															  TInt aPriority,

    65 															  TInt aPref)

    66 	{

    67 	CMdaAudioPlayerUtility* self = new(ELeave) CMdaAudioPlayerUtility();

    68 	CleanupStack::PushL(self);

    69 	self->iProperties = CMMFMdaAudioPlayerUtility::NewL(aCallback, aPriority, aPref);

    70 	CleanupStack::Pop(self);

    71 	return self;

    72 	}

    73 

    74 /**

    75 Constructs and initialises a new instance of the audio player utility for playing sampled audio data 

    76 from a file. The audio data must be in a supported format (e.g. WAV and AU).

    77 

    78 The function leaves if the audio player utility object cannot be created.

    79 

    80 When initialisation of the audio player utility is complete, successfully or otherwise, the callback 

    81 function MMdaAudioPlayerCallback::MapcInitComplete() is called.

    82 

    83 @param  aFileName 

    84         The full path name of the file containing the audio data.

    85 @param  aCallback 

    86         The audio player observer interface.

    87 @param  aPriority

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

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

    90 @param  aPref

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

    92         EMdaPriorityPreferenceNone. Further values are given by TMdaPriorityPreference, and additional 

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

    94         portable code.

    95 @param  aServer

    96         Not used in 7.0s. This parameter is provided for binary compatibility with previous versions.

    97 

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

    99 

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

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

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

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

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

   105 */

   106 EXPORT_C CMdaAudioPlayerUtility* CMdaAudioPlayerUtility::NewFilePlayerL(const TDesC& aFileName,

   107 																		MMdaAudioPlayerCallback& aCallback,

   108 																		TInt aPriority,

   109 																		TInt aPref,

   110 																		CMdaServer* /*aServer*/)

   111 	{

   112 	CMdaAudioPlayerUtility* self = new(ELeave) CMdaAudioPlayerUtility();

   113 	CleanupStack::PushL(self);

   114 	self->iProperties = CMMFMdaAudioPlayerUtility::NewFilePlayerL(aFileName, aCallback, aPriority, aPref);

   115 	CleanupStack::Pop(self);

   116 	return self;

   117 	}

   118 

   119 /**

   120 Constructs and initialises a new instance of the audio player utility for playing sampled audio data 

   121 from a descriptor.

   122 

   123 The audio data must be in a supported format (e.g. WAV and AU).

   124 

   125 The function leaves if the audio player utility object cannot be created. When initialisation of the 

   126 audio player utility is complete, successfully or otherwise, the callback function 

   127 MMdaAudioPlayerCallback::MapcInitComplete() is called.

   128 

   129 @param  aData 

   130         A descriptor containing the audio data. This descriptor must remain in existence for the 

   131         lifetime of this audio player utility object.

   132 @param  aCallback 

   133         The audio player observer interface.

   134 @param  aPriority

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

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

   137 @param  aPref

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

   139         EMdaPriorityPreferenceNone. Further values are given by TMdaPriorityPreference, and additional 

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

   141         portable code.

   142 @param  aServer

   143         Not used in 7.0s. This parameter is provided for binary compatibility with previous versions.

   144 

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

   146 

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

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

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

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

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

   152 */

   153 EXPORT_C CMdaAudioPlayerUtility* CMdaAudioPlayerUtility::NewDesPlayerL(const TDesC8& aData, MMdaAudioPlayerCallback& aCallback, TInt aPriority, TInt aPref, CMdaServer* /*aServer*/)

   154 	{

   155 	CMdaAudioPlayerUtility* self = new(ELeave) CMdaAudioPlayerUtility();

   156 	CleanupStack::PushL(self);

   157 	self->iProperties = CMMFMdaAudioPlayerUtility::NewDesPlayerL(aData, aCallback, aPriority, aPref);

   158 	CleanupStack::Pop(self);

   159 	return self;

   160 	}

   161 

   162 /**

   163 Constructs and initialises a new instance of the audio player utility for playing sampled audio data 

   164 from a read only descriptor.

   165 

   166 The audio data must be in a supported format (e.g. WAV and AU).

   167 

   168 The function leaves if the audio player utility object cannot be created. When initialisation of 

   169 the audio player utility is complete, successfully or otherwise, the callback function 

   170 MMdaAudioPlayerCallback::MapcInitComplete() is called.

   171 

   172 @param  aData 

   173         A read only descriptor containing the audio data. This descriptor must remain in existence 

   174         for the lifetime of this audio player utility object.

   175 @param  aCallback 

   176         The audio player observer interface.

   177 @param  aPriority

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

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

   180 @param  aPref

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

   182         EMdaPriorityPreferenceNone. Further values are given by TMdaPriorityPreference, and additional 

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

   184         portable code.

   185 @param  aServer

   186         Not used in 7.0s. This parameter is provided for binary compatibility with previous versions.

   187 

   188 @return A pointer to a new audio player utility.

   189 

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

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

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

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

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

   195 */

   196 EXPORT_C CMdaAudioPlayerUtility* CMdaAudioPlayerUtility::NewDesPlayerReadOnlyL(const TDesC8& aData, MMdaAudioPlayerCallback& aCallback, TInt aPriority, TInt aPref, CMdaServer* /*aServer*/)

   197 	{

   198 	CMdaAudioPlayerUtility* self = new(ELeave) CMdaAudioPlayerUtility();

   199 	CleanupStack::PushL(self);

   200 	self->iProperties = CMMFMdaAudioPlayerUtility::NewDesPlayerReadOnlyL(aData, aCallback, aPriority, aPref);

   201 	CleanupStack::Pop(self);

   202 	return self;

   203 	}

   204 

   205 CMdaAudioPlayerUtility::CMdaAudioPlayerUtility()

   206 	{

   207 	}

   208 

   209 /**

   210 Destructor.

   211 

   212 Frees all resources owned by the object prior to its destruction.

   213 */

   214 CMdaAudioPlayerUtility::~CMdaAudioPlayerUtility()

   215 	{

   216 	delete iProperties;

   217 	}

   218 

   219 /**

   220 Ensures that any subsequent calls to OpenXYZ() will create controllers that

   221 share a heap.

   222 

   223 The default behaviour is that for each player utility a controller with its own heap

   224 is created. Each heap uses a chunk, so using this function avoids situations where 

   225 the number of chunks per process is limited.

   226 The default behaviour is generally to be preferred, and should give lower overall

   227 memory usage. However, if many controllers are to be created for a particular thread,

   228 then this function should be used to prevent running out of heaps or chunks.

   229 

   230 @since	9.1

   231 */

   232 EXPORT_C void CMdaAudioPlayerUtility::UseSharedHeap()

   233 	{

   234 	ASSERT(iProperties);

   235 	iProperties->UseSharedHeap();

   236 	}

   237 

   238 // 5.0 functions

   239 

   240 /**

   241 Begins playback of audio sample data at the current playback position using the current volume,

   242 gain and priority settings.

   243 

   244 When playing of the audio sample is complete, successfully or

   245 otherwise, the callback function

   246 MMdaAudioPlayerCallback::MapcPlayComplete() is

   247 called.

   248 

   249 If this function is called whilst already playing then 

   250 MMdaAudioPlayerCallback::MapcPlayComplete will return with the

   251 error code KErrNotReady.

   252 

   253 @since	5.0

   254 */

   255 void CMdaAudioPlayerUtility::Play()

   256 	{

   257 	ASSERT(iProperties);

   258 	iProperties->Play();

   259 	}

   260 

   261 /**

   262 Stops playback of the audio sample as soon as possible.

   263 

   264 If the audio sample is playing, playback is stopped as soon as

   265 possible. If playback is already complete, nothing further happens as

   266 a result of calling this function. The callback function

   267 MMdaAudioPlayerCallback::MapcPlayComplete() is not

   268 called.

   269 

   270 @since	5.0

   271 */

   272 void CMdaAudioPlayerUtility::Stop()

   273 	{

   274 	ASSERT(iProperties);

   275 	iProperties->Stop();

   276 	}

   277 

   278 

   279 /**

   280 Changes the current playback volume to a specified value.

   281 

   282 The volume can be changed before or during playback and is effective

   283 immediately. The volume can be set to any value between zero (mute) and 

   284 the maximum permissible volume (determined using MaxVolume()).

   285 

   286 @param  aVolume

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

   288         the value returned by a call to

   289         CMdaAudioPlayerUtility::MaxVolume().

   290         Setting a zero value mutes the sound. Setting the maximum

   291         value results in the loudest possible sound. Values less 

   292         than zero would be set to zero and the values greater than 

   293         the maximum permitted volume would be set to the maximum volume.

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

   295 		otherwise another of the system-wide error codes.

   296 @panic  EMMFMediaClientBadArgument is raised when the audio player utility is not initialised.

   297 

   298 @since	5.0

   299 */

   300 TInt CMdaAudioPlayerUtility::SetVolume(TInt aVolume)

   301 	{

   302 	ASSERT(iProperties);

   303 	return iProperties->SetVolume(aVolume);

   304 	}

   305 

   306 /**

   307 Sets the number of times the audio sample is to be repeated during the

   308 playback operation.

   309 

   310 A period of silence can follow each playing of the sample. The audio

   311 sample can be repeated indefinitely.

   312 

   313 @param   aRepeatNumberOfTimes

   314          The number of times the audio sample, together with

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

   316          set to KMdaRepeatForever, then the audio

   317          sample, together with the trailing silence, is

   318          repeated indefinitely or until Stop() is

   319          called. If this is set to zero, then the audio sample

   320          is not repeated.

   321 @param   aTrailingSilence

   322          The time interval of the trailing silence in microseconds.

   323 

   324 @since	5.0

   325 */

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

   327 	{

   328 	ASSERT(iProperties);

   329 	iProperties->SetRepeats(aRepeatNumberOfTimes, aTrailingSilence);

   330 	}

   331 

   332 /**

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

   334 from nothing to the normal volume level.

   335 

   336 @param  aRampDuration

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

   338         value causes the audio sample to be played at the

   339         normal level for the full duration of the playback. A

   340         value which is longer than the duration of the audio

   341         sample means that the sample never reaches its normal

   342         volume level.

   343 

   344 @since	5.0

   345 */

   346 void CMdaAudioPlayerUtility::SetVolumeRamp(const TTimeIntervalMicroSeconds& aRampDuration)

   347 	{

   348 	ASSERT(iProperties);

   349 	iProperties->SetVolumeRamp(aRampDuration);

   350 	}

   351 

   352 /**

   353 Returns the duration of the audio sample in microseconds.

   354 

   355 @return The duration of the sample in microseconds.

   356 

   357 @since	5.0

   358 */

   359 const TTimeIntervalMicroSeconds& CMdaAudioPlayerUtility::Duration()

   360 	{

   361 	ASSERT(iProperties);

   362 	return iProperties->Duration();

   363 	}

   364 

   365 /**

   366 Returns the duration of the audio sample in microseconds, and the duration state.

   367 

   368 @param aDuration

   369 	   The duration of the sample in microseconds.

   370 @return The duration state

   371 

   372 @since	9.1

   373 */	

   374 EXPORT_C TMMFDurationInfo CMdaAudioPlayerUtility::Duration(TTimeIntervalMicroSeconds& aDuration)

   375 {

   376 	ASSERT(iProperties);

   377 	return iProperties->Duration(aDuration);

   378 }

   379 

   380 /**

   381 Returns an integer representing the maximum volume.

   382 

   383 This is the maximum value which can be passed to

   384 CMdaAudioPlayerUtility::SetVolume(). This value is platform 

   385 independent, but is always greater than or equal to one.

   386 

   387 @return The maximum volume setting.

   388 @panic  EMMFMediaClientPanicServerCommunicationProblem is raised when the audio player utility is not initialised. 

   389 

   390 @since	5.0

   391 */

   392 TInt CMdaAudioPlayerUtility::MaxVolume()

   393 	{

   394 	ASSERT(iProperties);

   395 	return iProperties->MaxVolume();

   396 	}

   397 

   398 // 7.0s functions

   399 

   400 /**

   401 Opens an audio clip from a file.

   402 

   403 The audio data must be in a supported format (for example, WAV or AU).

   404 

   405 This function leaves with KErrNotReady if there is a previous open statement awaiting notification of completion.

   406 

   407 @param  aFileName

   408         The file to open.

   409 @leave  KErrNotReady

   410         If a previous open statement is awaiting notification of completion.

   411 		opening the file

   412 @since	7.0s

   413 */

   414 EXPORT_C void CMdaAudioPlayerUtility::OpenFileL(const TDesC& aFileName)

   415 	{

   416 	ASSERT(iProperties);

   417 	iProperties->OpenFileL(aFileName);

   418 	}

   419 	

   420 /**

   421 Opens an audio clip from a file.

   422 

   423 The audio data must be in a supported format (for example, WAV or AU).

   424 

   425 This function leaves with KErrNotReady if there is a previous open statement awaiting notification of completion.

   426 

   427 Note: it is generally advisable that the RFile is shared through the call RFs::ShareProtected().

   428 This allows the adaptation to pass it to another process, if that is required. This is particularly

   429 true of playing DRM encrypted files.

   430 

   431 @param  aFile

   432         The open shared session file handle to use

   433 @leave 	KErrBadHandle

   434 		If the file handle is not shared through the call RFs::ShareProtected(), and the adaptation needs it to be.

   435 @leave  KErrNotReady

   436         If a previous open statement is awaiting notification of completion.

   437 		opening the file

   438 */

   439 EXPORT_C void CMdaAudioPlayerUtility::OpenFileL(const RFile& aFile)

   440 	{

   441 	ASSERT(iProperties);

   442 	RFile& file = const_cast<RFile&>(aFile);

   443 	TMMFileHandleSource tfs(file, KDefaultContentObject, EPlay);

   444 	iProperties->OpenFileL(tfs);

   445 	}

   446 

   447 /**

   448 Opens an audio clip from a file.

   449 

   450 The audio data must be in a supported format (for example, WAV or AU).

   451 

   452 This function leaves with KErrNotReady if there is a previous open statement awaiting notification of completion.

   453 

   454 @param  aSource

   455         The file to open or an open file handle to use

   456 @leave  KErrNotReady

   457         If a previous open statement is awaiting notification of completion.

   458 		opening the file

   459 */

   460 EXPORT_C void CMdaAudioPlayerUtility::OpenFileL(const TMMSource& aSource)

   461 	{

   462 	ASSERT(iProperties);

   463 	iProperties->OpenFileL(aSource);

   464 	}

   465 	

   466 /**

   467 Opens an audio clip from a descriptor.

   468 

   469 The audio data must be in a supported format (for example, WAV or AU).

   470 

   471 @param  aDescriptor

   472         A descriptor containing the audio clip.

   473 @leave  KErrInUse

   474         If a previous open statement is awaiting notification of completion.

   475 

   476 @since	7.0s

   477 */

   478 EXPORT_C void CMdaAudioPlayerUtility::OpenDesL(const TDesC8& aDescriptor)

   479 	{

   480 	ASSERT(iProperties);

   481 	iProperties->OpenDesL(aDescriptor);

   482 	}

   483 

   484 /**

   485 Opens an audio clip from a URL.

   486 

   487 The audio data must be in a supported format (for example, WAV or AU).

   488 

   489 @param	aUrl

   490 		The URL to open.

   491 @param 	aIapId

   492 		Internet access point(IAP) ID to use. KUseDefaultIap selects the default IAP.

   493 @param  aMimeType

   494 		MIME type of the URL source.

   495 

   496 @leave  KErrInUse 

   497         If a previous open statement is awaiting notification of completion.

   498 

   499 @since  7.0s

   500 */

   501 EXPORT_C void CMdaAudioPlayerUtility::OpenUrlL(const TDesC& aUrl, const TInt aIapId /*=KUseDefaultIap*/, const TDesC8& aMimeType /*=KNullDesC8*/)

   502 	{

   503 	ASSERT(iProperties);

   504 	iProperties->OpenUrlL(aUrl, aIapId, aMimeType);

   505 	}

   506 

   507 /**

   508 Pauses the playback of the audio clip.

   509 

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

   511         another of the system-wide error codes.

   512 

   513 @since	7.0s

   514 */

   515 EXPORT_C TInt CMdaAudioPlayerUtility::Pause()

   516 	{

   517 	ASSERT(iProperties);

   518 	return iProperties->Pause();

   519 	}

   520 

   521 /**

   522 Closes the current audio clip (allowing another clip to be opened).

   523 

   524 @since	7.0s

   525 */

   526 EXPORT_C void CMdaAudioPlayerUtility::Close()

   527 	{

   528 	ASSERT(iProperties);

   529 	iProperties->Close();

   530 	}

   531 

   532 /**

   533 Returns the current playback position in microseconds from the start of the clip.

   534 

   535 @param   aPosition

   536          The current time position in microseconds from the start of the clip to the current

   537          play position.

   538 

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

   540         another of the system-wide error codes.

   541 

   542 @since	7.0s

   543 */

   544 EXPORT_C TInt CMdaAudioPlayerUtility::GetPosition(TTimeIntervalMicroSeconds& aPosition)

   545 	{

   546 	ASSERT(iProperties);

   547 	return iProperties->GetPosition(aPosition);

   548 	}

   549 

   550 /**

   551 Sets the current playback position in microseconds from the start of the clip.

   552 

   553 @param  aPosition

   554         The position to move to in microseconds from the start of the clip.

   555 

   556 @since	7.0s

   557 */

   558 EXPORT_C void CMdaAudioPlayerUtility::SetPosition(const TTimeIntervalMicroSeconds& aPosition)

   559 	{

   560 	ASSERT(iProperties);

   561 	iProperties->SetPosition(aPosition);

   562 	}

   563 

   564 /**

   565 Sets the priority for playback. This is used to arbitrate between multiple

   566 objects trying to access a single sound device.

   567 

   568 @param  aPriority

   569         The Priority Value.

   570 @param  aPref

   571         The Priority Preference.

   572 

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

   574         another of the system-wide error codes.

   575 

   576 @since  7.0s

   577 

   578 @see CMdaAudioPlayerUtility::NewL()

   579 

   580 */

   581 EXPORT_C TInt CMdaAudioPlayerUtility::SetPriority(TInt aPriority, TInt aPref)

   582 	{

   583 	ASSERT(iProperties);

   584 	return iProperties->SetPriority(aPriority, aPref);

   585 	}

   586 

   587 /**

   588 Returns the current playback volume.

   589 

   590 @param  aVolume

   591         A value between 0 and the maximum volume settings returned by MaxVolume().

   592 

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

   594         another of the system-wide error codes.

   595 

   596 @since	7.0s

   597 */

   598 EXPORT_C TInt CMdaAudioPlayerUtility::GetVolume(TInt& aVolume)

   599 	{

   600 	ASSERT(iProperties);

   601 	return iProperties->GetVolume(aVolume);

   602 	}

   603 

   604 /**

   605 Returns the number of meta data entries in the current audio clip.

   606 

   607 @param  aNumEntries

   608         The number of meta data entries in the header of the current clip.

   609 

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

   611         another of the system-wide error codes.

   612 

   613 @since	7.0s

   614 */

   615 EXPORT_C TInt CMdaAudioPlayerUtility::GetNumberOfMetaDataEntries(TInt& aNumEntries)

   616 	{

   617 	ASSERT(iProperties);

   618 	return iProperties->GetNumberOfMetaDataEntries(aNumEntries);

   619 	}

   620 

   621 /**

   622 Returns the requested meta data entry.

   623 

   624 @param  aMetaDataIndex

   625         The index number of the meta data to retrieve.

   626 

   627 @return The requested meta data entry.

   628 @leave  KErrNotFound

   629         The meta data entry does not exist.

   630 @leave  KErrNotImplemented

   631         The controller does not support meta data information for this format.

   632 

   633 @since	7.0s

   634 */

   635 EXPORT_C CMMFMetaDataEntry* CMdaAudioPlayerUtility::GetMetaDataEntryL(TInt aMetaDataIndex)

   636 	{

   637 	ASSERT(iProperties);

   638 	return iProperties->GetMetaDataEntryL(aMetaDataIndex);

   639 	}

   640 

   641 /**

   642 Defines a window on the audio sample data.

   643 

   644 The window is defined in terms of a start and end position.

   645 When the current playback position reaches the window end position, or Stop() is called, the

   646 current playback position is set to the window start position and playback stops.

   647 

   648 The current playback position is not affected by a call to SetPlayWindow() unless it is outside

   649 the new playback window, in which case it is set to the window start or end position depending

   650 on which one is closer.

   651 

   652 The window persists until ClearPlayWindow() is called.

   653 Loading new audio sample data without adjusting or clearing the window will result in

   654 playback errors if the window is outside the new data.

   655 

   656 @param  aStart

   657         The position defining the start of the window, measured in microseconds. If this value is less

   658         than zero, it is set to zero. If this value is greater than aEnd, then it is swapped with aEnd.

   659 @param  aEnd

   660         The position defining the end of the window, measured in microseconds. If this value is greater

   661         than the value returned by Duration(), it is set to the value of Duration(). If this value is

   662         less than aStart, then it is swapped with aStart.

   663 

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

   665         another of the system-wide error codes.

   666 

   667 @since	7.0s

   668 */

   669 EXPORT_C TInt CMdaAudioPlayerUtility::SetPlayWindow(const TTimeIntervalMicroSeconds& aStart,

   670 													const TTimeIntervalMicroSeconds& aEnd)

   671 	{

   672 	ASSERT(iProperties);

   673 	return iProperties->SetPlayWindow(aStart, aEnd);

   674 	}

   675 

   676 /**

   677 Clears the current playback window.

   678 

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

   680         another of the system-wide error codes.

   681 

   682 @since	7.0s

   683 */

   684 EXPORT_C TInt CMdaAudioPlayerUtility::ClearPlayWindow()

   685 	{

   686 	ASSERT(iProperties);

   687 	return iProperties->ClearPlayWindow();

   688 	}

   689 

   690 /**

   691 Sets the current playback balance.

   692 

   693 @param  aBalance

   694         A value between KMMFBalanceMaxLeft

   695         and KMMFBalanceMaxRight. The default value is

   696         KMMFBalanceCenter.

   697 

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

   699         another of the system-wide error codes.

   700 

   701 @since  7.0s

   702 */

   703 EXPORT_C TInt CMdaAudioPlayerUtility::SetBalance(TInt aBalance /*= KMMFBalanceCenter*/)

   704 	{

   705 	ASSERT(iProperties);

   706 	return iProperties->SetBalance(aBalance);

   707 	}

   708 

   709 /**

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

   711  *			as passed to SetBalance depending on the internal implementation in 

   712  *			the underlying components.

   713  *

   714  *	@param  aBalance

   715  *        	A value between KMMFBalanceMaxLeft

   716  *       	and KMMFBalanceMaxRight.

   717  *

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

   719  *        	another of the system-wide error codes.

   720  *

   721  *	@since	7.0s

   722  */

   723 EXPORT_C TInt CMdaAudioPlayerUtility::GetBalance(TInt& aBalance)

   724 	{

   725 	ASSERT(iProperties);

   726 	return iProperties->GetBalance(aBalance);

   727 	}

   728 

   729 /**

   730 Returns the controller implementation information associated with the current controller.

   731 

   732 @return The controller implementation structure

   733 

   734 @since 7.0s

   735 */

   736 EXPORT_C const CMMFControllerImplementationInformation& CMdaAudioPlayerUtility::ControllerImplementationInformationL()

   737 	{

   738 	ASSERT(iProperties);

   739 	return iProperties->ControllerImplementationInformationL();

   740 	}

   741 

   742 /**

   743 Registers callback object to receive notifications of audio loading/rebuffering.

   744 

   745 @param  aCallback

   746         The object to receive audio loading notifications.

   747 

   748 @since  7.0s

   749 */

   750 EXPORT_C void CMdaAudioPlayerUtility::RegisterForAudioLoadingNotification(MAudioLoadingObserver& aCallback)

   751 	{

   752 	ASSERT(iProperties);

   753 	iProperties->RegisterForAudioLoadingNotification(aCallback);

   754 	}

   755 

   756 /**

   757 Returns the current progress of audio loading.

   758 

   759 @param  aPercentageProgress

   760         The percentage of the audio clip loaded.

   761 

   762 @since  7.0s

   763 */

   764 EXPORT_C void CMdaAudioPlayerUtility::GetAudioLoadingProgressL(TInt& aPercentageProgress)

   765 	{

   766 	ASSERT(iProperties);

   767 	iProperties->GetAudioLoadingProgressL(aPercentageProgress);

   768 	}

   769 

   770 /**

   771 Sends a synchronous custom command to the controller.

   772 

   773 @param  aDestination

   774         The destination of the message, consisting of the UID of

   775         the interface of this message.

   776 @param  aFunction

   777         The function number to indicate which function is to be called

   778         on the interface defined in the aDestination parameter.

   779 @param  aDataTo1

   780         A reference to the first chunk of data to be copied to the controller

   781         framework. The exact contents of the data are dependent on the

   782         interface being called.  Can be KNullDesC8.

   783 @param  aDataTo2

   784         A reference to the second chunk of data to be copied to the controller

   785         framework. The exact contents of the data are dependent on the

   786         interface being called.  Can be KNullDesC8.

   787 @param  aDataFrom

   788         A reference to an area of memory to which the controller framework will

   789         write any data to be passed back to the client.  Can't be KNullDesC8.

   790 

   791 @return The result of the request.  Exact range of values is dependent on the interface.

   792 

   793 @since  7.0s

   794 */

   795 EXPORT_C TInt CMdaAudioPlayerUtility::CustomCommandSync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2, TDes8& aDataFrom)

   796 	{

   797 	ASSERT(iProperties);

   798 	return iProperties->CustomCommandSync(aDestination, aFunction, aDataTo1, aDataTo2, aDataFrom);

   799 	}

   800 

   801 /**

   802 Sends a synchronous custom command to the controller.

   803 

   804 @param  aDestination

   805         The destination of the message, consisting of the UID of

   806         the interface of this message.

   807 @param  aFunction

   808         The function number to indicate which function is to be called

   809         on the interface defined in the aDestination parameter.

   810 @param  aDataTo1

   811         A reference to the first chunk of data to be copied to the controller

   812         framework. The exact contents of the data are dependent on the

   813         interface being called.  Can be KNullDesC8.

   814 @param  aDataTo2

   815         A reference to the second chunk of data to be copied to the controller

   816         framework. The exact contents of the data are dependent on the

   817         interface being called.  Can be KNullDesC8.

   818 

   819 @return The result of the request.  Exact range of values is dependent on the interface.

   820 

   821 @since  7.0s

   822 */

   823 EXPORT_C TInt CMdaAudioPlayerUtility::CustomCommandSync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2)

   824 	{

   825 	ASSERT(iProperties);

   826 	return iProperties->CustomCommandSync(aDestination, aFunction, aDataTo1, aDataTo2);

   827 	}

   828 

   829 /**

   830 Sends an asynchronous custom command to the controller.

   831 

   832 Note: 

   833 This method will return immediately.  The RunL of the active object owning the

   834 aStatus parameter will be called when the command is completed by the

   835 controller framework.

   836 

   837 @param  aDestination

   838         The destination of the message, consisting of the uid of

   839         the interface of this message.

   840 @param  aFunction

   841         The function number to indicate which function is to be called

   842         on the interface defined in the aDestination parameter.

   843 @param  aDataTo1

   844         A reference to the first chunk of data to be copied to the controller

   845         framework. The exact contents of the data are dependent on the

   846         interface being called.  Can be KNullDesC8.

   847 @param  aDataTo2

   848         A reference to the second chunk of data to be copied to the controller

   849         framework. The exact contents of the data are dependent on the

   850         interface being called.  Can be KNullDesC8.

   851 @param  aDataFrom

   852         A reference to an area of memory to which the controller framework will

   853         write any data to be passed back to the client.  Can't be KNullDesC8."

   854 @param  aStatus

   855         The TRequestStatus of an active object.  This will contain the

   856         result of the request on completion.  The exact range of

   857         result values is dependent on the interface.

   858 

   859 @since  7.0s

   860 */

   861 EXPORT_C void CMdaAudioPlayerUtility::CustomCommandAsync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2, TDes8& aDataFrom, TRequestStatus& aStatus)

   862 	{

   863 	ASSERT(iProperties);

   864 	iProperties->CustomCommandAsync(aDestination, aFunction, aDataTo1, aDataTo2, aDataFrom, aStatus);

   865 	}

   866 

   867 /**

   868 Sends an asynchronous custom command to the controller.

   869 

   870 Note: 

   871 This method will return immediately.  The RunL of the active object owning the

   872 aStatus parameter will be called when the command is completed by the

   873 controller framework.

   874 

   875 @param  aDestination

   876         The destination of the message, consisting of the uid of

   877         the interface of this message.

   878 @param  aFunction

   879         The function number to indicate which function is to be called

   880         on the interface defined in the aDestination parameter.

   881 @param  aDataTo1

   882         A reference to the first chunk of data to be copied to the controller

   883         framework. The exact contents of the data are dependent on the

   884         interface being called.  Can be KNullDesC8.

   885 @param  aDataTo2

   886         A reference to the second chunk of data to be copied to the controller

   887         framework. The exact contents of the data are dependent on the

   888         interface being called.  Can be KNullDesC8.

   889 @param  aStatus

   890         The TRequestStatus of an active object.  This will contain the

   891         result of the request on completion.  The exact range of

   892         result values is dependent on the interface.

   893 

   894 @since  7.0s

   895 */

   896 EXPORT_C void CMdaAudioPlayerUtility::CustomCommandAsync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2, TRequestStatus& aStatus)

   897 	{

   898 	ASSERT(iProperties);

   899 	iProperties->CustomCommandAsync(aDestination, aFunction, aDataTo1, aDataTo2, aStatus);

   900 	}

   901 

   902 /**

   903 Returns the bit rate of the audio clip.

   904 

   905 @param  aBitRate

   906 		The bit rate of the audio clip

   907 

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

   909 		otherwise another of the system-wide error codes.

   910 

   911 @since  7.0s

   912 */

   913 EXPORT_C TInt CMdaAudioPlayerUtility::GetBitRate(TUint& aBitRate)

   914 	{

   915 	ASSERT(iProperties);

   916 	return iProperties->GetBitRate(aBitRate);	

   917 	}

   918 

   919 /**

   920 Gets a controller's DRM custom command implementation.

   921 

   922 @return A pointer to a controller's DRM custom command implementation, or NULL if the

   923 controller does not support it.

   924 */

   925 EXPORT_C MMMFDRMCustomCommand* CMdaAudioPlayerUtility::GetDRMCustomCommand()

   926 	{

   927 	ASSERT(iProperties);

   928 	return iProperties->GetDRMCustomCommand();

   929 	}

   930 

   931 /**

   932 Registers the Event for Notification when resource is avaliable.

   933 

   934 @param	aCallback

   935       	The audio outputstream observer interface..

   936       	

   937 @param 	aNotificationEventUid

   938  	The Event for which the client is registered.

   939  	

   940 @param 	aNotificationRegistrationData

   941 	Notification registration specific data.

   942 	

   943 @return An error code indicating if the registration was successful. KErrNone on success, 

   944 	otherwise another of the system-wide error codes.

   945 */

   946 EXPORT_C TInt CMdaAudioPlayerUtility::RegisterAudioResourceNotification(MMMFAudioResourceNotificationCallback& aCallback,TUid aNotificationEventUid,const TDesC8& aNotificationRegistrationData)

   947 	{

   948 	ASSERT(iProperties);

   949 	return iProperties->RegisterAudioResourceNotification(aCallback,aNotificationEventUid,aNotificationRegistrationData);

   950 	}

   951 

   952 /**

   953 Cancels the registered notification event.

   954 

   955 @param  aNotificationEventUid

   956 	The Event to notify the client.

   957 	

   958 @return An error code indicating if the registration was successful. KErrNone on success, 

   959 	otherwise another of the system-wide error codes.

   960 */

   961 EXPORT_C TInt CMdaAudioPlayerUtility::CancelRegisterAudioResourceNotification(TUid aNotificationEventUid)

   962 	{

   963 	ASSERT(iProperties);

   964 	return iProperties->CancelRegisterAudioResourceNotification(aNotificationEventUid);

   965 	}

   966 

   967 /**

   968 Waits for the client to resume the play even after the default timer expires.

   969 

   970 @return An error code indicating if the registration was successful. KErrNone on success, 

   971 		otherwise another of the system-wide error codes.

   972 */

   973 EXPORT_C TInt CMdaAudioPlayerUtility::WillResumePlay()

   974 	{

   975 	ASSERT(iProperties);

   976 	return iProperties->WillResumePlay();

   977 	}

   978 

   979 

   980 /**

   981 Set the priority of the controller's sub thread.

   982 

   983 This can be used to increase the responsiveness of the audio plugin to minimise

   984 any lag in processing. This function should be used with care as it may have knock-on

   985 effects elsewhere in the system.

   986 

   987 @param	aPriority

   988 		The TThreadPriority that the thread should run under.  The default is EPriorityNormal.

   989 @return	TInt

   990 		A standard error code: KErrNone if successful, KErrNotReady if the thread does not have a

   991 		valid handle.

   992 */

   993 EXPORT_C TInt CMdaAudioPlayerUtility::SetThreadPriority(const TThreadPriority& aPriority) const

   994 	{

   995 	ASSERT(iProperties);

   996 	return iProperties->SetThreadPriority(aPriority);

   997 	}

   998 

   999 

  1000 

  1001 

  1002 CMMFMdaAudioPlayerUtility* CMMFMdaAudioPlayerUtility::NewL(MMdaAudioPlayerCallback& aCallback,

  1003 															  TInt aPriority,

  1004 															  TInt aPref)

  1005 	{

  1006 	CMMFMdaAudioPlayerUtility* self = new(ELeave) CMMFMdaAudioPlayerUtility(aCallback, aPriority, aPref);

  1007 	CleanupStack::PushL(self);

  1008 	self->ConstructL();

  1009 	CleanupStack::Pop(self);

  1010 	return self;

  1011 	}

  1012 

  1013 CMMFMdaAudioPlayerUtility* CMMFMdaAudioPlayerUtility::NewFilePlayerL(const TDesC& aFileName,

  1014 																		MMdaAudioPlayerCallback& aCallback,

  1015 																		TInt aPriority,

  1016 																		TInt aPref,

  1017 																		CMdaServer* /*aServer*/)

  1018 	{

  1019 	CMMFMdaAudioPlayerUtility* self = new(ELeave) CMMFMdaAudioPlayerUtility(aCallback, aPriority, aPref);

  1020 	CleanupStack::PushL(self);

  1021 	self->ConstructL();

  1022 	TMMFileSource filesource(aFileName, KDefaultContentObject, EPlay);

  1023 	self->OpenFileL(filesource);

  1024 	CleanupStack::Pop(self);

  1025 	return self;

  1026 	}

  1027 

  1028 CMMFMdaAudioPlayerUtility* CMMFMdaAudioPlayerUtility::NewDesPlayerL(const TDesC8& aData, MMdaAudioPlayerCallback& aCallback, TInt aPriority, TInt aPref, CMdaServer* /*aServer*/)

  1029 	{

  1030 	CMMFMdaAudioPlayerUtility* self = new(ELeave) CMMFMdaAudioPlayerUtility(aCallback, aPriority, aPref);

  1031 	CleanupStack::PushL(self);

  1032 	self->ConstructL();

  1033 	self->OpenDesL(aData);

  1034 	CleanupStack::Pop(self);

  1035 	return self;

  1036 	}

  1037 

  1038 CMMFMdaAudioPlayerUtility* CMMFMdaAudioPlayerUtility::NewDesPlayerReadOnlyL(const TDesC8& aData, MMdaAudioPlayerCallback& aCallback, TInt aPriority, TInt aPref, CMdaServer* /*aServer*/)

  1039 	{

  1040 	CMMFMdaAudioPlayerUtility* self = new(ELeave) CMMFMdaAudioPlayerUtility(aCallback, aPriority, aPref);

  1041 	CleanupStack::PushL(self);

  1042 	self->ConstructL();

  1043 	self->OpenDesL(aData);

  1044 	CleanupStack::Pop(self);

  1045 	return self;

  1046 	}

  1047 

  1048 void CMMFMdaAudioPlayerUtility::UseSharedHeap()

  1049 	{

  1050 	iFindAndOpenController->UseSharedHeap();

  1051 	}

  1052 

  1053 // CMMFMdaAudioPlayerUtility

  1054 CMMFMdaAudioPlayerUtility::~CMMFMdaAudioPlayerUtility()

  1055 	{

  1056 	

  1057 	delete iControllerImplementationInformation;

  1058 	delete iAsyncCallBack;

  1059 	delete iRepeatTrailingSilenceTimer;

  1060 	delete iFindAndOpenController;

  1061 	delete iControllerEventMonitor;

  1062 	iMediaIds.Close();

  1063 	iController.Close();

  1064 	}

  1065 

  1066 CMMFMdaAudioPlayerUtility::CMMFMdaAudioPlayerUtility(MMdaAudioPlayerCallback& aCallback, TInt aPriority, TInt aPref) :

  1067 	iCallback(aCallback),

  1068 	iAudioPlayDeviceCommands(iController),

  1069 	iAudioPlayControllerCommands(iController),

  1070 	iNotificationRegistrationCommands(iController),

  1071 	iDRMCustomCommands(iController),

  1072 	iAudioPlayControllerSetRepeatsCommands(iController)

  1073 	{

  1074 	iState = EStopped;

  1075 	iPrioritySettings.iPriority = aPriority;

  1076 	iPrioritySettings.iPref = aPref;

  1077 	iPlayStart = TTimeIntervalMicroSeconds(0);

  1078 	iPlayEnd = TTimeIntervalMicroSeconds(0);

  1079 	iPlayWindowSet = ENone;

  1080 	iEventHolder = KNullUid;

  1081 	}

  1082 

  1083 void CMMFMdaAudioPlayerUtility::ConstructL()

  1084 	{

  1085 	iControllerEventMonitor = CMMFControllerEventMonitor::NewL(*this, iController);

  1086 	iRepeatTrailingSilenceTimer = CRepeatTrailingSilenceTimer::NewL(*this);

  1087 	iAsyncCallBack = CMMFMdaAudioPlayerCallBack::NewL(iCallback);

  1088 	User::LeaveIfError(iMediaIds.Append(KUidMediaTypeAudio));

  1089 	iFindAndOpenController = CMMFFindAndOpenController::NewL(*this);

  1090 	iFindAndOpenController->Configure(iMediaIds[0], iPrioritySettings);

  1091 	iFindAndOpenController->ConfigureController(iController, *iControllerEventMonitor, CMMFFindAndOpenController::EPlayback);

  1092 	}

  1093 

  1094 void CMMFMdaAudioPlayerUtility::MfaocComplete(		

  1095 		TInt& aError, 

  1096 		RMMFController* /*aController*/,

  1097 		TUid aControllerUid, 

  1098 		TMMFMessageDestination* /*aSourceHandle*/, 

  1099 		TMMFMessageDestination* /*aSinkHandle*/)

  1100 	{

  1101 	if (aError == KErrNone)

  1102 		{

  1103 		iControllerUid = aControllerUid;

  1104 

  1105 		// Get the clip duration

  1106 		iDuration = TTimeIntervalMicroSeconds(0);

  1107 		aError = iController.GetDuration(iDuration);

  1108 				

  1109 		// If an error occurred during GetDuration, may try for next controller, if present.

  1110 		if (aError != KErrNone)

  1111 			{

  1112 			iControllerEventMonitor->Cancel();

  1113 			

  1114 			if (iFindAndOpenController)	

  1115 				{

  1116 				if(iFindAndOpenController-> ControllerIndex() < (iFindAndOpenController->ControllerCount())-1)

  1117 					{

  1118 					return;   //actually tries to load next controllers, if there are other controllers selected in the controller list

  1119 					}

  1120 				}

  1121 			

  1122 			iController.Close(); // otherwise close the controller

  1123 			}

  1124 	

  1125 		if (iFindAndOpenController)	

  1126 			{

  1127 			iFindAndOpenController->Close();

  1128 			}

  1129 		}

  1130 	

  1131 	iAsyncCallBack->InitComplete(aError, iDuration);

  1132 	}

  1133 

  1134 /**