1 /*

     2 * Copyright (c) 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:  This class plays local audio file

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 //<branchInfo originator="alakurik" since="26-NOV-2007"/>

    21 // Including adaptationaudiopreference.h instead of audiopreference.h to

    22 // bring in needed constants for __HIGH_RESOLUTION_VOLUME

    23 //</branchInfo>

    24 //BRANCH 26-NOV-2007

    25 //#include <audiopreference.h>

    26 //BRANCH_END

    27 #if defined(__HIGH_RESOLUTION_VOLUME) && !defined(__LOW_POWER_AUDIO_PLAYBACK)

    28 #include <adaptationaudiopreference.h>

    29 #else

    30 #include <AudioPreference.h>

    31 #endif

    32 #include <badesca.h>

    33 #include <apgcli.h>

    34 #include <mmf/common/mmfcontrollerframeworkbase.h>

    35 #include <mmf/common/mmfmeta.h>

    36 #include <mpxmedia.h>

    37 #include <mpxdrmmediautility.h>

    38 #include <mpxmediadrmdefs.h>

    39 #include <mpxplaybackpluginobserver.h>

    40 #include <mpxmediaaudiodefs.h>

    41 #include <mpxmediamusicdefs.h>

    42 #include <mpxmediageneraldefs.h>

    43 #include <mpxmediadrmdefs.h>

    44 #include "mpxaudioeffectengine.h"

    45 #include <mpxprivatecrkeys.h>

    46 #include <mpxcenrepwatcher.h>

    47 

    48 #include "mpxlocalaudioplayback.h"

    49 #include "mpxlog.h"

    50 

    51 // CONSTANTS

    52 const TUid  KLocalPlaybackUid={0x101FFC06};

    53 _LIT(KWmaExtension, ".wma");

    54 _LIT(KRaExtension, ".ra"); 

    55 

    56     

    57 // ============================ LOCAL FUNCTIONS ==============================

    58 LOCAL_C TInt Balance(TInt aMMFBalance)

    59     {

    60     return (aMMFBalance-KMMFBalanceCenter) *

    61            (EPbBalanceMaxRight-EPbBalanceMaxLeft) /

    62            (KMMFBalanceMaxRight-KMMFBalanceMaxLeft);

    63     }

    64 

    65 LOCAL_C TInt MMFBalance(TInt aBalance)

    66     {

    67     return KMMFBalanceCenter+(KMMFBalanceMaxRight-KMMFBalanceMaxLeft)/

    68            (EPbBalanceMaxRight-EPbBalanceMaxLeft)*aBalance;

    69     }

    70 

    71 

    72 // ============================ MEMBER FUNCTIONS ==============================

    73 

    74 // ----------------------------------------------------------------------------

    75 // Two-phased constructor.

    76 // ----------------------------------------------------------------------------

    77 //

    78 CMPXLocalAudioPlayback* CMPXLocalAudioPlayback::NewL(TAny* /*aInitParams*/)

    79     {

    80     CMPXLocalAudioPlayback* p=new(ELeave)CMPXLocalAudioPlayback();

    81     CleanupStack::PushL(p);

    82     p->ConstructL();

    83     CleanupStack::Pop(p);

    84     return p;

    85     }

    86 

    87 // ----------------------------------------------------------------------------

    88 // Symbian 2nd phase constructor can leave.

    89 // ----------------------------------------------------------------------------

    90 //

    91 void CMPXLocalAudioPlayback::ConstructL()

    92     {

    93     MPX_FUNC_EX("CMPXLocalAudioPlayback::ConstructL()");

    94     iVolumeWatcher = CMPXCenRepWatcher::NewL(KCRUidMPXSettings,

    95                                              KMPXPlaybackVolume,

    96                                              this);

    97 

    98     iMuteWatcher = CMPXCenRepWatcher::NewL(KCRUidMPXSettings,

    99                                            KMPXPlaybackMute,

   100                                            this);

   101 

   102     iPlayer = CMdaAudioPlayerUtility::NewL(*this,

   103 #ifdef __LOW_POWER_AUDIO_PLAYBACK

   104                         KAudioPriorityMusicPlayer,

   105                         TMdaPriorityPreference(KAudioPrefMusicLocalPlayback));

   106 #else

   107 #ifdef __HIGH_RESOLUTION_VOLUME

   108                         KAudioPriorityTwentyStepsVolumeMusicPlayer,

   109                         TMdaPriorityPreference(KAudioPrefTwentyStepsVolumeMusicPlayerPlayback));

   110 #else

   111                         KAudioPriorityRealOnePlayer,

   112                         TMdaPriorityPreference(KAudioPrefRealOneLocalPlayback));

   113 #endif // __HIGH_RESOLUTION_VOLUME

   114 #endif // __LOW_POWER_AUDIO_PLAYBACK

   115 

   116     User::LeaveIfError(iFs.Connect());

   117     iFs.ShareProtected();

   118     iDrmMediaUtility = CMPXDrmMediaUtility::NewL();

   119     iAudioEffects = CMPXAudioEffectEngine::NewL( iPlayer );

   120     }

   121 

   122 // ----------------------------------------------------------------------------

   123 // C++ constructor

   124 // ----------------------------------------------------------------------------

   125 //

   126 CMPXLocalAudioPlayback::CMPXLocalAudioPlayback()

   127 	: iAudioEffectsOn(ETrue), iIsPlaying(EFalse)

   128     {}

   129 

   130 // ----------------------------------------------------------------------------

   131 // Destructor

   132 // ----------------------------------------------------------------------------

   133 //

   134 CMPXLocalAudioPlayback::~CMPXLocalAudioPlayback()

   135     {

   136     MPX_FUNC_EX("CMPXLocalAudioPlayback::~CMPXLocalAudioPlayback");

   137     delete iMuteWatcher;

   138     delete iVolumeWatcher;

   139     if ( iDrmMediaUtility )

   140         {

   141         TRAP_IGNORE( ConsumeRightsL( ContentAccess::EStop ) );

   142         iDrmMediaUtility->Close();

   143         delete iDrmMediaUtility;

   144         }

   145     if( iAudioEffects )

   146         {

   147         iAudioEffects->DestroyAudioEffect();

   148         delete iAudioEffects;

   149         }

   150     if (iPlayer)

   151         {

   152         iPlayer->Close();

   153         delete iPlayer;

   154         }

   155     iFile.Close();

   156     iFs.Close();

   157     delete iSong;

   158     }

   159 

   160 // ----------------------------------------------------------------------------

   161 // Set observer

   162 // ----------------------------------------------------------------------------

   163 //

   164 void CMPXLocalAudioPlayback::SetObserver(MMPXPlaybackPluginObserver& aObs)

   165     {

   166     MPX_FUNC_EX("CMPXLocalAudioPlayback::SetObserver(MMPXPlaybackPluginObserver& aObs)");

   167     iObs = &aObs;

   168     }

   169 

   170 // ----------------------------------------------------------------------------

   171 // Initializes a song for playback

   172 // ----------------------------------------------------------------------------

   173 //

   174 void CMPXLocalAudioPlayback::InitialiseL(const TDesC& aSong)

   175     {

   176     MPX_DEBUG3("-->CMPXLocalAudioPlayback::InitialiseL 0x%08x, (%S)", this, &aSong);

   177 

   178     iDrmMediaUtility->Close();

   179     delete iSong;

   180     iSong = NULL;

   181     iSong = aSong.AllocL();

   182     iFile.Close();

   183     TInt err( iFile.Open( iFs, aSong, EFileRead | EFileShareReadersOrWriters ));

   184     // Remap KErrNotReady to KErrNotFound, because it is referencing a drive

   185     // that is not existent

   186     if ( KErrNotReady == err )

   187         {

   188         err = KErrNotFound;

   189         }

   190     User::LeaveIfError( err );

   191     

   192 #if defined(__HIGH_RESOLUTION_VOLUME)

   193     TParsePtrC parser(aSong);

   194     

   195     // Merlin twentysteps hack start

   196     if (parser.Ext().CompareF(KWmaExtension) == 0 || parser.Ext().CompareF(KRaExtension) == 0)

   197         {

   198         // This is a wma song, need to delete iPlayer and reset the volume resolution

   199         // this is because the volume level 20 is not supported for wma with headphone

   200         MPX_DEBUG1("CMPXLocalAudioPlayback::InitialiseL it is a wma file, so set to 10 steps");

   201         delete iAudioEffects;

   202         iAudioEffects = NULL;

   203         delete iPlayer;

   204         iPlayer = NULL;

   205         iPlayer = CMdaAudioPlayerUtility::NewL(*this,

   206                         KAudioPriorityRealOnePlayer,

   207                         TMdaPriorityPreference(KAudioPrefRealOneLocalPlayback));

   208         // Also regenerate audio effects

   209         iAudioEffects = CMPXAudioEffectEngine::NewL( iPlayer );

   210         }                        

   211     // Merlin twentysteps hack end

   212 #endif // __HIGH_RESOLUTION_VOLUME

   213     TMMFileHandleSource source(iFile, KDefaultContentObject, EPlay);

   214     iPlayer->OpenFileL(source);

   215     iDrmMediaUtility->InitL( iFile );

   216     iState = EStateInitialising;

   217     iClosedByAudioPolicy = EFalse;

   218     iConsumeStarted = EFalse;

   219 

   220     MPX_DEBUG3("<--CMPXLocalAudioPlayback::InitialiseL 0x%08x, (%S)", this, &aSong);

   221     }

   222 

   223 // ----------------------------------------------------------------------------

   224 // Initializes a song for playback

   225 // ----------------------------------------------------------------------------

   226 //

   227 void CMPXLocalAudioPlayback::InitialiseL(RFile& aSong)

   228     {

   229     MPX_DEBUG2("-->CMPXLocalAudioPlayback::InitialiseL(RFile) 0x%08x", this);

   230 

   231     iDrmMediaUtility->Close();

   232     delete iSong;

   233     iSong = NULL;

   234     iSong = HBufC::NewL(KMaxFileName);

   235     TPtr ptr = iSong->Des();

   236     aSong.FullName(ptr);

   237     

   238 #if defined(__HIGH_RESOLUTION_VOLUME)

   239     TParsePtrC parser(ptr);

   240     

   241     // Merlin twentysteps hack start

   242     if (parser.Ext().CompareF(KWmaExtension) == 0 || parser.Ext().CompareF(KRaExtension) == 0)

   243         {

   244         // This is a wma song, need to delete iPlayer and reset the volume resolution

   245         // this is because the volume level 20 is not supported for wma with headphone

   246         delete iAudioEffects;

   247         iAudioEffects = NULL;

   248         delete iPlayer;

   249         iPlayer = NULL;

   250         iPlayer = CMdaAudioPlayerUtility::NewL(*this,

   251                         KAudioPriorityRealOnePlayer,

   252                         TMdaPriorityPreference(KAudioPrefRealOneLocalPlayback));

   253         // Also regenerate audio effects

   254         iAudioEffects = CMPXAudioEffectEngine::NewL( iPlayer );

   255         }    

   256     // Merlin twentysteps hack end

   257 #endif // __HIGH_RESOLUTION_VOLUME

   258     TMMFileHandleSource source(aSong, KDefaultContentObject, EPlay);

   259     iPlayer->OpenFileL(source);

   260     User::LeaveIfError( iFile.Duplicate( aSong ));

   261     iDrmMediaUtility->InitL( iFile );

   262     iState = EStateInitialising;

   263     iClosedByAudioPolicy = EFalse;

   264     iConsumeStarted = EFalse;

   265 

   266     MPX_DEBUG2("<--CMPXLocalAudioPlayback::InitialiseL(RFile) 0x%08x", this);

   267     }

   268 

   269 // ----------------------------------------------------------------------------

   270 // Executes a command on the selected song

   271 // ----------------------------------------------------------------------------

   272 //

   273 void CMPXLocalAudioPlayback::CommandL(TMPXPlaybackCommand aCmd, TInt aData)

   274     {

   275     MPX_DEBUG3("-->CMPXLocalAudioPlayback::CommandL 0x%08x cmd %d", this, aCmd);

   276     switch(aCmd)

   277         {

   278         case EPbCmdPlay:

   279             {

   280             // If closed by audio policy, then play command will need to

   281             // re-initialise the plugin first.

   282             if ( iClosedByAudioPolicy )

   283                 {

   284                 HBufC* song( iSong->AllocLC() );

   285                 InitialiseL( *song );

   286                 iConsumeStarted = ETrue;

   287                 CleanupStack::PopAndDestroy( song );

   288                 iClosedByAudioPolicy = EFalse;

   289                 }

   290             else

   291                 {

   292                 // Treat song as play complete if try to play at end of song

   293                 TTimeIntervalMicroSeconds dur( iPlayer->Duration() );

   294                 TTimeIntervalMicroSeconds pos( 0 );

   295                 TInt err( iPlayer->GetPosition( pos ));

   296                 MPX_DEBUG4("CMPXLocalAudioPlayback::CommandL(): dur=%d, pos=%d, err=%d", I64INT(dur.Int64()), I64INT(pos.Int64()), err);

   297                 if ( !err &&

   298                      Abs( dur.Int64() - pos.Int64() ) < KPbMilliMultiplier &&

   299                      dur.Int64() > KPbMilliMultiplier )

   300                     {

   301                     MapcPlayComplete( KErrNone );

   302                     }

   303                 else

   304                     {

   305                     if (iConsumeStarted)

   306                         {

   307                         TRAPD( drmErr, ConsumeRightsL( ContentAccess::EContinue ) );

   308                         if ( drmErr == KErrCANoRights )

   309                             {

   310                             iDrmMediaUtility->Close();

   311                             iPlayer->Stop();

   312                             iIsPlaying = EFalse;

   313                             iAudioEffects->DestroyAudioEffect();

   314                             iPlayer->Close();

   315                             iObs->HandlePluginEvent(

   316                                     MMPXPlaybackPluginObserver::EPStopped, 0,

   317                                     drmErr);

   318                             iFile.Close();

   319                             iState = EStateNotInitialised;

   320                             iObs->HandlePluginEvent(

   321                                     MMPXPlaybackPluginObserver::EPClosed,

   322                                     EPbCmdStop, drmErr);

   323                             iClosedByAudioPolicy = EFalse;

   324                             break;

   325                             }

   326                         }

   327                     else

   328                         {

   329                         MPX_TRAPD( AEErr,  ConsumeRightsL( ContentAccess::EPlay ) );

   330                         if (AEErr == KErrDiskFull)

   331                         	{

   332                         	iDrmMediaUtility->Close();

   333 				            iPlayer->Stop();

   334 				            iIsPlaying = EFalse;

   335 				            iAudioEffects->DestroyAudioEffect();

   336 				            iPlayer->Close();

   337 				            iObs->HandlePluginEvent(MMPXPlaybackPluginObserver::EPStopped,

   338 				                    0, KErrDiskFull);

   339 				            iFile.Close();

   340 				            iState = EStateNotInitialised;

   341 				            iObs->HandlePluginEvent(MMPXPlaybackPluginObserver::EPClosed,

   342 				                                    EPbCmdStop, KErrDiskFull);

   343 				            iClosedByAudioPolicy = EFalse;

   344 				            break;

   345                         	}

   346                         iConsumeStarted = ETrue;

   347                         }

   348 

   349 					if ( iAudioEffectsOn )

   350 						{

   351                     	MPX_TRAP( err,  iAudioEffects->CreateAudioEffectsL() );

   352 						}

   353 

   354                     iPlayer->Play();

   355                     iIsPlaying = ETrue;

   356 

   357                     if( iAudioEffectsOn && err != KErrNone )

   358                         {

   359                         MPX_TRAP( err,  iAudioEffects->CreateAudioEffectsL() );

   360                         }

   361 

   362                     iObs->HandlePluginEvent(MMPXPlaybackPluginObserver::EPPlaying,

   363                                              0, KErrNone);

   364                     }

   365                 }

   366             break;

   367             }

   368         case EPbCmdPause:

   369             {

   370             TRAP_IGNORE( ConsumeRightsL( ContentAccess::EPause ) );

   371 

   372             TInt err( iPlayer->Pause() );

   373             iIsPlaying = EFalse;

   374             iAudioEffects->DestroyAudioEffect();

   375 

   376             MPX_DEBUG2("CMPXLocalAudioPlayback::CommandL(): Pause err = %d", err);

   377             // If pause is not supported, resend the play command so plugin

   378             // state is correct.

   379             // This is for cases like playing .RNG files

   380             if ( KErrNotSupported == err )

   381                 {

   382                 iObs->HandlePluginEvent( MMPXPlaybackPluginObserver::EPPaused,

   383                                          0,

   384                                          KErrNone);

   385                 iPlayer->Play();

   386                 iIsPlaying = ETrue;

   387                 iObs->HandlePluginEvent( MMPXPlaybackPluginObserver::EPPlaying,

   388                                          0,

   389                                          KErrNone);

   390                 }

   391             else

   392                 {

   393                 iObs->HandlePluginEvent( MMPXPlaybackPluginObserver::EPPaused,

   394                                          0,

   395                                          err);

   396                 }

   397             iClosedByAudioPolicy = EFalse;

   398             break;

   399             }

   400         case EPbCmdStop:

   401             {

   402             TRAP_IGNORE( ConsumeRightsL( ContentAccess::EStop ));

   403             iConsumeStarted = EFalse;

   404             iDrmMediaUtility->Close();

   405             iPlayer->Stop();

   406             iIsPlaying = EFalse;

   407             iAudioEffects->DestroyAudioEffect();

   408             iPlayer->Close();

   409 

   410             iObs->HandlePluginEvent(MMPXPlaybackPluginObserver::EPStopped,

   411                     0, KErrNone);

   412             iFile.Close();

   413             iState = EStateNotInitialised;

   414             iObs->HandlePluginEvent(MMPXPlaybackPluginObserver::EPClosed,

   415                                     EPbCmdStop, KErrNone);

   416             iClosedByAudioPolicy = EFalse;

   417             break;

   418             }

   419         case EPbCmdClose:

   420             {

   421             TRAP_IGNORE( ConsumeRightsL( ContentAccess::EStop ));

   422             iConsumeStarted = EFalse;

   423             iDrmMediaUtility->Close();

   424             iAudioEffects->DestroyAudioEffect();

   425             iPlayer->Close();

   426             iIsPlaying = EFalse;

   427             iFile.Close();

   428             iState = EStateNotInitialised;

   429             iObs->HandlePluginEvent(MMPXPlaybackPluginObserver::EPClosed,

   430                                     EPbCmdClose, KErrNone);

   431             iClosedByAudioPolicy = EFalse;

   432             break;

   433             }

   434         case EPbApplyEffect:

   435             {

   436             // Re-init audio effects

   437             MPX_DEBUG1("CMPXLocalAudioPlayback::CommandL EPbApplyEffect");

   438             if( ( aData == KAudioEffectsID || aData == KEqualizerID ) &&

   439                 ( EStateInitialised == iState ) )

   440                 {

   441                 TRAP_IGNORE( iAudioEffects->CreateAudioEffectsL() );

   442                 iAudioEffectsOn = ETrue;

   443                 }

   444             break;

   445             }

   446         case EPbCmdCloseItem:

   447             {

   448             iDrmMediaUtility->Close();

   449             iPlayer->Close();

   450             iIsPlaying = EFalse;

   451             iFile.Close();

   452             iState = EStateNotInitialised;

   453             iClosedByAudioPolicy = EFalse;

   454             break;

   455             }

   456         case EPbCmdDisableEffect:

   457         	{

   458 			iAudioEffectsOn = EFalse;

   459 			break;

   460 			}

   461 		default:

   462 			break;

   463         }

   464     MPX_DEBUG3("<--CMPXLocalAudioPlayback::CommandL 0x%08x cmd %d", this, aCmd);

   465     }

   466 

   467 // ----------------------------------------------------------------------------

   468 // Sets a property of the plugin

   469 // ----------------------------------------------------------------------------

   470 //

   471 void CMPXLocalAudioPlayback::SetL(TMPXPlaybackProperty aProperty,TInt aValue)

   472     {

   473     MPX_DEBUG4("-->CMPXLocalAudioPlayback::SetL 0x%08x, (prop %d, val %d)",

   474                this, aProperty, aValue);

   475     TBool isSupported=ETrue;

   476     switch(aProperty)

   477         {

   478         case EPbPropertyVolume:

   479             {

   480             SetVolume( aValue );

   481             break;

   482             }

   483         case EPbPropertyVolumeRamp:

   484             iPlayer->SetVolumeRamp(TTimeIntervalMicroSeconds(TInt64(aValue)));

   485             break;

   486         case EPbPropertyMute:

   487             SetMute( aValue );

   488             break;

   489         case EPbPropertyBalance:

   490             iPlayer->SetBalance(MMFBalance(aValue));

   491             break;

   492         case EPbPropertyPosition:

   493             {

   494             TInt64 pos(aValue);

   495             pos *= KPbMilliMultiplier;

   496             

   497             if (iIsPlaying)

   498                 {

   499                 iPlayer->Pause();

   500                 iPlayer->SetPosition(pos);

   501                 //Handle error of license expired when tapping the progress playing bar 

   502                 TRAPD( drmErr, ConsumeRightsL( ContentAccess::EContinue ) );

   503                 if ( drmErr == KErrCANoRights )

   504                     {

   505                     iDrmMediaUtility->Close();

   506                     iPlayer->Stop();

   507                     iIsPlaying = EFalse;

   508                     iAudioEffects->DestroyAudioEffect();

   509                     iPlayer->Close();

   510                     iObs->HandlePluginEvent(

   511                             MMPXPlaybackPluginObserver::EPStopped, 0, drmErr);

   512                     iFile.Close();

   513                     iState = EStateNotInitialised;

   514                     iObs->HandlePluginEvent(

   515                             MMPXPlaybackPluginObserver::EPClosed, EPbCmdStop,

   516                             drmErr);

   517                     iClosedByAudioPolicy = EFalse;

   518                     return;

   519                     }

   520                 iPlayer->Play();

   521                 }

   522             else

   523                 {

   524                 iPlayer->SetPosition(pos);

   525                 }

   526             }

   527             break;

   528         default:

   529             isSupported=EFalse;

   530         }

   531 

   532     if (!isSupported)

   533         {

   534         User::Leave(KErrNotSupported);

   535         }

   536     iObs->HandlePluginEvent(MMPXPlaybackPluginObserver::EPSetComplete,

   537                              aProperty, KErrNone);

   538     MPX_DEBUG4("<--CMPXLocalAudioPlayback::SetL 0x%08x, (prop %d, val %d)",

   539                this, aProperty, aValue);

   540     }

   541 

   542 // ----------------------------------------------------------------------------

   543 // Gets a property of the plugin (async)

   544 // ----------------------------------------------------------------------------

   545 //

   546 void CMPXLocalAudioPlayback::PropertyL(TMPXPlaybackProperty aProperty) const

   547     {

   548     MPX_DEBUG3("-->CMPXLocalAudioPlayback::PropertyL 0x%08x (prop %d)",

   549                this, aProperty);

   550     TBool isSupported=ETrue;

   551     TInt value=KErrNotFound;

   552     TInt err(KErrNone);

   553     switch(aProperty)

   554         {

   555         case EPbPropertyVolume:

   556             {

   557             value = iVolumeWatcher->CurrentValueL();

   558             break;

   559             }

   560         case EPbPropertyMaxVolume:

   561             value=iPlayer->MaxVolume();

   562             break;

   563         case EPbPropertyMute:

   564             value = iMuteWatcher->CurrentValueL();

   565             break;

   566         case EPbPropertyBalance:

   567             err = iPlayer->GetBalance(value);

   568             value=Balance(value);

   569             break;

   570         case EPbPropertyDuration:

   571             {

   572             TTimeIntervalMicroSeconds duration = iPlayer->Duration();

   573             value = duration.Int64() / KPbMilliMultiplier;

   574             }

   575             break;

   576         case EPbPropertyPosition:

   577             {

   578             TTimeIntervalMicroSeconds pos;

   579             iPlayer->GetPosition(pos);

   580             MPX_DEBUG2("CMPXLocalAudioPlayback::PropertyL position %ld", pos.Int64());

   581             value = pos.Int64() / KPbMilliMultiplier;

   582             }

   583             break;

   584         case EPbPropertySupportedFeatures:

   585             value = EPbFeatureBalance | EPbFeatureVolumeRamp;

   586             break;

   587         default:

   588             isSupported=EFalse;

   589         }

   590     if (!isSupported)

   591         {

   592         User::Leave(KErrNotSupported);

   593         }

   594     iObs->HandleProperty(aProperty,value,err);

   595     MPX_DEBUG3("<--CMPXLocalAudioPlayback::PropertyL 0x%08x (prop %d)",

   596                this, aProperty);

   597     }

   598 

   599 // ----------------------------------------------------------------------------

   600 // Gets a list of sub players, UPnP only

   601 // ----------------------------------------------------------------------------

   602 //

   603 void CMPXLocalAudioPlayback::SubPlayerNamesL()

   604     {

   605     iObs->HandleSubPlayerNames(KLocalPlaybackUid, NULL, ETrue, KErrNone);

   606     }

   607 

   608 // ----------------------------------------------------------------------------

   609 // Select a sub player

   610 // ----------------------------------------------------------------------------

   611 //

   612 void CMPXLocalAudioPlayback::SelectSubPlayerL(TInt /*aIndex*/)

   613     {

   614     User::Leave(KErrNotSupported);

   615     }

   616 

   617 // ----------------------------------------------------------------------------

   618 // Returns current sub player name

   619 // ----------------------------------------------------------------------------

   620 //

   621 const TDesC& CMPXLocalAudioPlayback::SubPlayerName()

   622     {

   623     return KNullDesC; //No subplayer name for local playback

   624     }

   625 

   626 // ----------------------------------------------------------------------------

   627 // Current sub player index

   628 // ----------------------------------------------------------------------------

   629 //

   630 TInt CMPXLocalAudioPlayback::SubPlayerIndex() const

   631    {

   632    return KErrNotFound;

   633    }

   634 

   635 // ----------------------------------------------------------------------------

   636 // Gets media properties

   637 // ----------------------------------------------------------------------------

   638 //

   639 void CMPXLocalAudioPlayback::MediaL(const TArray<TMPXAttribute>& aAttrs)

   640     {

   641     MPX_DEBUG2("-->CMPXLocalAudioPlayback::MediaL 0x%08x", this);

   642     RArray<TInt> suppIds;

   643     CleanupClosePushL(suppIds);

   644     suppIds.AppendL(KMPXMediaIdMusic);

   645     suppIds.AppendL(KMPXMediaIdGeneral);

   646     suppIds.AppendL(KMPXMediaIdAudio);

   647     suppIds.AppendL(KMPXMediaIdDrm);

   648     CMPXMedia* media=CMPXMedia::NewL(suppIds.Array());

   649     CleanupStack::PopAndDestroy(&suppIds);

   650     CleanupStack::PushL(media);

   651 

   652     if ( EStateInitialised == iState )

   653         {

   654         TUint attrG(0); // General attributes

   655         TUint attrA(0); // Audio attributes

   656         TUint attrM(0); // Music attributes

   657         TUint attrD(0); // DRM attributes

   658 

   659         for (TInt i=aAttrs.Count(); --i>=0;)

   660             {

   661             TMPXAttribute attr(aAttrs[i]);

   662             if (attr.ContentId() == KMPXMediaIdGeneral)

   663                 {

   664                 attrG |= attr.AttributeId();

   665                 }

   666             else if (attr.ContentId() == KMPXMediaIdMusic)

   667                 {

   668                 attrM |= attr.AttributeId();

   669                 }

   670             else if (attr.ContentId() == KMPXMediaIdAudio)

   671                 {

   672                 attrA |= attr.AttributeId();

   673                 }

   674             else if ( attr.ContentId() == KMPXMediaIdDrm )

   675                 {

   676                 attrD |= attr.AttributeId();

   677                 }

   678             }

   679 

   680         TInt metaCount = 0;

   681 

   682         // Get metadata from MMF

   683         TInt error = iPlayer->GetNumberOfMetaDataEntries(metaCount);

   684         CMMFMetaDataEntry* metaData = NULL;

   685 

   686         if (!error)

   687             {

   688             for (TInt i = 0; i < metaCount; ++i)

   689                 {

   690                 metaData = iPlayer->GetMetaDataEntryL(i);

   691                 CleanupStack::PushL(metaData);

   692 

   693                 if (metaData->Name().CompareF(KMMFMetaEntrySongTitle()) == 0 &&

   694                     attrG & EMPXMediaGeneralTitle)

   695                     { // TODO to check request

   696                     media->SetTextValueL(

   697                         TMPXAttribute(KMPXMediaIdGeneral,EMPXMediaGeneralTitle),

   698                         metaData->Value());

   699                     }

   700                 else if (metaData->Name().CompareF(KMMFMetaEntryArtist()) == 0 &&

   701                     attrM & EMPXMediaMusicArtist)

   702                     {

   703                     media->SetTextValueL(

   704                         TMPXAttribute(KMPXMediaIdMusic,EMPXMediaMusicArtist),

   705                         metaData->Value());

   706                     }

   707                 else if (metaData->Name().CompareF(KMMFMetaEntryAlbum()) == 0 &&

   708                     attrM & EMPXMediaMusicAlbum)

   709                     {

   710                     media->SetTextValueL(

   711                         TMPXAttribute(KMPXMediaIdMusic,EMPXMediaMusicAlbum),

   712                         metaData->Value());

   713                     }

   714                 else if (metaData->Name().CompareF(KMMFMetaEntryYear()) == 0 &&

   715                     attrM & EMPXMediaMusicYear)

   716                     {

   717                     TInt year;

   718                     TLex lex( metaData->Value() );

   719                     lex.Val( year );

   720 

   721                     TDateTime dt;

   722                     dt.SetYear( year );

   723                     TTime time( dt );

   724 

   725                     media->SetTObjectValueL(

   726                         TMPXAttribute(KMPXMediaIdMusic,EMPXMediaMusicYear),

   727                         time.Int64());

   728                     }

   729                 else if (metaData->Name().CompareF(KMMFMetaEntryComment()) == 0 &&

   730                     attrG & EMPXMediaGeneralComment)

   731                     {

   732                     media->SetTextValueL(

   733                         TMPXAttribute(KMPXMediaIdGeneral,EMPXMediaGeneralComment),

   734                         metaData->Value());

   735                     }

   736                 else if (metaData->Name().CompareF(KMMFMetaEntryComposer()) == 0 &&

   737                     attrM & EMPXMediaMusicComposer)

   738                     {

   739                     media->SetTextValueL(

   740                         TMPXAttribute(KMPXMediaIdMusic,EMPXMediaMusicComposer),

   741                         metaData->Value());

   742                     }

   743                 else if (metaData->Name().CompareF(KMMFMetaEntryAlbumTrack()) == 0 &&

   744                     attrM & EMPXMediaMusicAlbumTrack)

   745                     {

   746                     media->SetTextValueL(

   747                         TMPXAttribute(KMPXMediaIdMusic,EMPXMediaMusicAlbumTrack),

   748                         metaData->Value());

   749                     }

   750                 else if (metaData->Name().CompareF(KMMFMetaEntryGenre()) == 0 &&

   751                     attrM & EMPXMediaMusicGenre)

   752                     {

   753                     media->SetTextValueL(

   754                         TMPXAttribute(KMPXMediaIdMusic,EMPXMediaMusicGenre),

   755                         metaData->Value());

   756                     }

   757                 //else if (metaData->Name().CompareF(KMMFMetaEntryWOAF()) == 0 &&

   758                 //    attrM & EMPXMediaMusicGenre)

   759                 //    {

   760                     //media->SetTextValueL(

   761                     //    TMPXAttribute(KMPXMediaIdMusic,EMPXMediaMusicGenre),

   762                     //    metaData->Value());

   763                     //}

   764                 else if (metaData->Name().CompareF(KMMFMetaEntryAPIC()) == 0 &&

   765                     attrM & EMPXMediaMusicAlbumArtFileName)

   766                     {

   767                     // TODO check collection if user defined album art available

   768                     media->SetTextValueL(

   769                         TMPXAttribute(KMPXMediaIdMusic,EMPXMediaMusicAlbumArtFileName),

   770                         *iSong);

   771                     }

   772 

   773                 CleanupStack::PopAndDestroy(metaData);

   774                 metaData = NULL;

   775                 }

   776             if ( attrG & EMPXMediaGeneralTitle )

   777                 {

   778                 if ( !media->IsSupported(

   779                     TMPXAttribute(KMPXMediaIdGeneral,EMPXMediaGeneralTitle ) ) )

   780                     {

   781                     TParsePtrC ptr( *iSong );

   782                     media->SetTextValueL(

   783                         TMPXAttribute(KMPXMediaIdGeneral,EMPXMediaGeneralTitle),

   784                         ptr.Name() );

   785                     }

   786                 }

   787             }

   788         if (attrG & EMPXMediaGeneralUri)

   789             {

   790             media->SetTextValueL(

   791                 TMPXAttribute(KMPXMediaIdGeneral,EMPXMediaGeneralUri),

   792                 *iSong);

   793             }

   794 

   795         if (attrG & EMPXMediaGeneralDuration)

   796             {

   797             TTimeIntervalMicroSeconds duration = iPlayer->Duration();

   798             media->SetTObjectValueL<TInt>(

   799                    TMPXAttribute(KMPXMediaIdGeneral, EMPXMediaGeneralDuration),

   800                    duration.Int64() / KPbMilliMultiplier);

   801             }

   802 

   803 

   804         // Set bitrate TODO

   805         TPckgBuf<TMMFAudioConfig> data;

   806 

   807         const TMMFMessageDestinationPckg

   808             destinationPckg(KUidInterfaceMMFAudioController);

   809 

   810         if (attrA & EMPXMediaAudioBitrate)

   811             {

   812             error = iPlayer->CustomCommandSync(destinationPckg,

   813                 EMMFAudioControllerGetSourceBitRate, KNullDesC8, KNullDesC8, data);

   814             if (!error)

   815                 {

   816                 media->SetTObjectValueL<TInt>(

   817                        TMPXAttribute(KMPXMediaIdAudio, EMPXMediaAudioBitrate),

   818                        data().iSampleRate);

   819                 }

   820             }

   821 

   822         if (attrA & EMPXMediaAudioSamplerate)

   823             {

   824 

   825             // Set sampling rate

   826             error = iPlayer->CustomCommandSync(destinationPckg,

   827                 EMMFAudioControllerGetSourceSampleRate, KNullDesC8, KNullDesC8, data);

   828             if (!error)

   829                 {

   830                 media->SetTObjectValueL<TInt>(

   831                        KMPXMediaAudioSamplerate,

   832                        data().iSampleRate);

   833                 }

   834             }

   835        if (attrG & EMPXMediaGeneralSize)

   836             {

   837             TEntry entry;

   838             iFs.Entry(iSong->Des(), entry);

   839             media->SetTObjectValueL<TInt>(

   840                    TMPXAttribute(KMPXMediaIdGeneral, EMPXMediaGeneralSize),

   841                    entry.iSize);

   842             }

   843 

   844        if (attrG & EMPXMediaGeneralMimeType)

   845             {

   846             RApaLsSession aps;

   847             error  = aps.Connect(); // always fail in console test

   848             if (KErrNone == error)

   849                 {

   850                 CleanupClosePushL(aps);

   851                 TDataType dataType;

   852                 TUid ignore;

   853                 if(aps.AppForDocument(iSong->Des(),ignore,dataType)==KErrNone)

   854                     {

   855                     media->SetTextValueL(

   856                         TMPXAttribute(KMPXMediaIdGeneral,EMPXMediaGeneralMimeType),

   857                         dataType.Des());

   858                     }

   859                 CleanupStack::PopAndDestroy(&aps);

   860                 } // Notes, STIF console test always fail

   861             }

   862 

   863         // Set DRM info

   864         const CMPXMedia* drmMedia( iDrmMediaUtility->GetMediaL( attrD ));

   865         if ( drmMedia )

   866             {

   867             TInt count( drmMedia->Count() );

   868             for ( TInt i = 0; i < count; i++ )

   869                 {

   870                 TUint attrId( drmMedia->Attribute(i).AttributeId() );

   871                 if ( attrD & attrId )

   872                     {

   873                     TMPXAttribute mpxAtt( KMPXMediaIdDrm, attrId );

   874                     switch ( attrId )

   875                         {

   876                         case EMPXMediaDrmType:

   877                         case EMPXMediaDrmRightsStatus:

   878                         case EMPXMediaDrmRightsType:

   879                         case EMPXMediaDrmCount:

   880                             {

   881                             TInt val(

   882                                 drmMedia->ValueTObjectL<TInt>( mpxAtt ));

   883                             media->SetTObjectValueL( mpxAtt, val );

   884                             break;

   885                             }

   886                         case EMPXMediaDrmProtected:

   887                         case EMPXMediaDrmSendingAllowed:

   888                         case EMPXMediaDrmCanSetAutomated:

   889                         case EMPXMediaDrmHasInfoUrl:

   890                         case EMPXMediaDrmHasPreviewUrl:

   891                         case EMPXMediaDrmAboutToExpire:

   892                             {

   893                             TBool val(

   894                                 drmMedia->ValueTObjectL<TBool>( mpxAtt ));

   895                             media->SetTObjectValueL( mpxAtt, val );

   896                             break;

   897                             }

   898                         case EMPXMediaDrmStartTime:

   899                         case EMPXMediaDrmEndTime:

   900                         case EMPXMediaDrmIntervalStartTime:

   901                         case EMPXMediaDrmAccumulatedTime:

   902                             {

   903                             TInt64 val(

   904                                 drmMedia->ValueTObjectL<TInt64>( mpxAtt ));

   905                             media->SetTObjectValueL( mpxAtt, val );

   906                             break;

   907                             }

   908                         case EMPXMediaDrmInterval:

   909                             {

   910                             TTimeIntervalSeconds val(

   911                                 drmMedia->ValueTObjectL<TTimeIntervalSeconds>(mpxAtt));

   912                             media->SetTObjectValueL( mpxAtt, val );

   913                             break;

   914                             }

   915                         default:

   916                             {

   917                             break;

   918                             }

   919                         }   // end switch (attriId)

   920                     }   // end if ( attrD & attrId )

   921                 }

   922             }

   923         }

   924 

   925     iObs->HandleMedia(*media, KErrNone);

   926     CleanupStack::PopAndDestroy(media);

   927     MPX_DEBUG2("<--CMPXLocalAudioPlayback::MediaL 0x%08x", this);

   928     }

   929 

   930 // ----------------------------------------------------------------------------

   931 // Cancel request

   932 // ----------------------------------------------------------------------------

   933 //

   934 void CMPXLocalAudioPlayback::CancelRequest()

   935     {

   936     }

   937 

   938 // ----------------------------------------------------------------------------

   939 // File open complete event

   940 // ----------------------------------------------------------------------------

   941 //

   942 void CMPXLocalAudioPlayback::MapcInitComplete(TInt aError,

   943                                 const TTimeIntervalMicroSeconds& aDuration)

   944     {

   945     MPX_DEBUG4("-->CMPXLocalAudioPlayback::MapcInitComplete 0x%08x err (%d) duration (%Ld)",

   946                this, aError, aDuration.Int64());

   947     iState = EStateInitialised;

   948 

   949     // Restore volume level

   950     if ( KErrNone == aError )

   951         {

   952         TInt currentVol( 0 );

   953         MPX_TRAPD( volError, currentVol = iVolumeWatcher->CurrentValueL() );

   954         if ( volError == KErrNone )

   955             {

   956             SetVolume( currentVol );

   957             TBool mute( EFalse);

   958             MPX_TRAPD( muteError, mute = iMuteWatcher->CurrentValueL() );

   959             if ( muteError == KErrNone && mute )

   960                 {

   961                 SetMute(mute);

   962                 }

   963             }

   964         }

   965 

   966     // Disable automatic DRM consumption

   967     if ( iPlayer )

   968         {

   969         MMMFDRMCustomCommand* drmCustom = iPlayer->GetDRMCustomCommand();

   970         if ( drmCustom )

   971             {

   972             drmCustom->DisableAutomaticIntent( ETrue );

   973             }

   974         }

   975 

   976     iObs->HandlePluginEvent(MMPXPlaybackPluginObserver::EPInitialised,

   977                             aDuration.Int64()/KPbMilliMultiplier,aError);

   978 

   979     MPX_DEBUG4("<--CMPXLocalAudioPlayback::MapcInitComplete 0x%08x err (%d) duration (%Ld)",

   980                this, aError, aDuration.Int64());

   981     }

   982 

   983 // ----------------------------------------------------------------------------

   984 // File play complete event

   985 // ----------------------------------------------------------------------------

   986 //

   987 void CMPXLocalAudioPlayback::MapcPlayComplete(TInt aError)

   988     {

   989     MPX_DEBUG3("-->CMPXLocalAudioPlayback::MapcPlayComplete 0x%08x (err %d)",

   990                this, aError);

   991     iState = EStateNotInitialised;

   992     iIsPlaying = EFalse;

   993     if ( KErrNone != aError )

   994         {

   995         TRAP_IGNORE( ConsumeRightsL( ContentAccess::EPause ) );

   996         }

   997     else

   998         {

   999         TRAP_IGNORE( ConsumeRightsL( ContentAccess::EStop ) );

  1000         if ( iConsumeStarted )

  1001             {

  1002             iConsumeStarted = EFalse;

  1003             }

  1004         }

  1005 

  1006     TRAP_IGNORE( iAudioEffects->DestroyAudioEffect() );

  1007 

  1008     // If killed by audio policy, mimic a paused state

  1009     if ( KErrDied == aError || KErrAccessDenied == aError || KErrInUse == aError )

  1010         {

  1011         iClosedByAudioPolicy = ETrue;

  1012         iObs->HandlePluginEvent( MMPXPlaybackPluginObserver::EPPaused,

  1013                                  0,

  1014                                  aError );

  1015         }

  1016      // If disk removed

  1017      else if( KErrNotReady == aError )

  1018         {

  1019         MPX_DEBUG1("CMPXLocalAudioPlayback::MapcPlayComplete - KErrNotReady");

  1020 

  1021         iClosedByAudioPolicy = EFalse;

  1022         iObs->HandlePluginEvent( MMPXPlaybackPluginObserver::EPStopped,

  1023                                  0,

  1024                                  KErrNone );

  1025         }

  1026     else

  1027         {

  1028         iClosedByAudioPolicy = EFalse;

  1029         iObs->HandlePluginEvent(MMPXPlaybackPluginObserver::EPPlayComplete,0,aError);

  1030         }

  1031     MPX_DEBUG3("<--CMPXLocalAudioPlayback::MapcPlayComplete 0x%08x (err %d)",

  1032                this, aError);

  1033     }

  1034 

  1035 // ----------------------------------------------------------------------------

  1036 // Handle a change in a setting value.

  1037 // ----------------------------------------------------------------------------

  1038 //

  1039 void CMPXLocalAudioPlayback::HandleSettingChange(

  1040     const TUid& aRepositoryUid,

  1041     TUint32 aSettingId )

  1042     {

  1043     MPX_DEBUG2("-->CMPXLocalAudioPlayback::HandleSettingChange 0x%08x", this);

  1044 

  1045     if ( KCRUidMPXSettings == aRepositoryUid &&

  1046          KMPXPlaybackVolume == aSettingId )

  1047         {

  1048         MPX_DEBUG1("CMPXLocalAudioPlayback::HandleSettingChange() Volume setting changed");

  1049         TInt vol( 0 );

  1050         MPX_TRAPD( error, vol = iVolumeWatcher->CurrentValueL() );

  1051         if ( EStateInitialised == iState && error == KErrNone )

  1052             {

  1053             SetVolume( vol );

  1054             }

  1055         else if ( error == KErrNone )

  1056             {

  1057             // Do not need to set volume if not initialised,

  1058             // just notify observers

  1059             iObs->HandlePluginEvent( MMPXPlaybackPluginObserver::EPVolumeChanged,

  1060                                      vol,

  1061                                      KErrNone);

  1062             }

  1063         }

  1064     else if ( KCRUidMPXSettings == aRepositoryUid &&

  1065          KMPXPlaybackMute == aSettingId )

  1066         {

  1067         MPX_DEBUG1("CMPXLocalAudioPlayback::HandleSettingChange() Mute setting changed");

  1068         TBool mute( EFalse );

  1069         MPX_TRAPD( error, mute = static_cast<TBool>(iMuteWatcher->CurrentValueL()) );

  1070         if ( EStateInitialised == iState && error == KErrNone )

  1071             {

  1072             TInt oldVolume( 0 );

  1073             iPlayer->GetVolume( oldVolume );

  1074             if ( (mute && oldVolume != 0) || (!mute && oldVolume == 0) )

  1075                 {

  1076                 SetMute( mute );

  1077                 }

  1078             }

  1079         else if ( error == KErrNone )

  1080             {

  1081             // Do not need to set volume if not initialised,

  1082             // just notify observers

  1083             iObs->HandlePluginEvent( MMPXPlaybackPluginObserver::EPMuteChanged,

  1084                                      mute,

  1085                                      KErrNone);

  1086             }

  1087         }

  1088     MPX_DEBUG2("<--CMPXLocalAudioPlayback::HandleSettingChange 0x%08x", this);

  1089     }

  1090 

  1091 // ----------------------------------------------------------------------------

  1092 // Sets the volume level in audio controller

  1093 // ----------------------------------------------------------------------------

  1094 //

  1095 void CMPXLocalAudioPlayback::SetVolume( TInt aVolume )

  1096     {

  1097     MPX_DEBUG3("-->CMPXLocalAudioPlayback::SetVolume 0x%08x vol (%d)", this, aVolume);

  1098 

  1099     // Ensure that level is within min and max values

  1100     if ( aVolume > KPbPlaybackVolumeLevelMax )

  1101         {

  1102         aVolume = KPbPlaybackVolumeLevelMax;

  1103         }

  1104     if ( aVolume < KPbPlaybackVolumeLevelMin )

  1105         {

  1106         aVolume = KPbPlaybackVolumeLevelMin;

  1107         }

  1108 

  1109     TBool changed( EFalse );

  1110     // Change MMF Audio player's volume

  1111     if ( EStateInitialised == iState )

  1112         {

  1113         TInt newVolume( aVolume * iPlayer->MaxVolume() / 100 );

  1114         MPX_DEBUG2("CMPXLocalAudioPlayback::SetVolume(): Setting volume = %d", newVolume);

  1115 

  1116         // First check if MMF Audio player's volume is changed by new value

  1117         TInt oldVolume( 0 );

  1118         iPlayer->GetVolume( oldVolume );

  1119         if ( newVolume != oldVolume )

  1120             {

  1121             iPlayer->SetVolume( newVolume );

  1122             changed = ETrue;

  1123             }

  1124         }

  1125 

  1126     // Change setting in cenrep

  1127     TInt currentVol( 0 );

  1128     MPX_TRAPD( volError, currentVol = iVolumeWatcher->CurrentValueL() );

  1129     if ( volError == KErrNone && aVolume != currentVol )

  1130         {

  1131         MPX_TRAP( volError, iVolumeWatcher->SetValueL( aVolume ) );

  1132         if( aVolume == 0 )

  1133             {

  1134             MPX_TRAP( volError, iMuteWatcher->SetValueL( ETrue ) );