/*

* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  This class plays local audio file

*

*/

// INCLUDE FILES

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

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

// bring in needed constants for __HIGH_RESOLUTION_VOLUME

//</branchInfo>

//BRANCH 26-NOV-2007

//#include <audiopreference.h>

//BRANCH_END

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

#include <adaptationaudiopreference.h>

#else

#include <AudioPreference.h>

#endif

#include <badesca.h>

#include <apgcli.h>

#include <mmf/common/mmfcontrollerframeworkbase.h>

#include <mmf/common/mmfmeta.h>

#include <mpxmedia.h>

#include <mpxdrmmediautility.h>

#include <mpxmediadrmdefs.h>

#include <mpxplaybackpluginobserver.h>

#include <mpxmediaaudiodefs.h>

#include <mpxmediamusicdefs.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediadrmdefs.h>

#include "mpxaudioeffectengine.h"

#include <mpxprivatecrkeys.h>

#include <mpxcenrepwatcher.h>

#include "mpxlocalaudioplayback.h"

#include "mpxlog.h"

// CONSTANTS

const TUid  KLocalPlaybackUid={0x101FFC06};

_LIT(KWmaExtension, ".wma");

_LIT(KRaExtension, ".ra"); 

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

LOCAL_C TInt Balance(TInt aMMFBalance)

    {

    return (aMMFBalance-KMMFBalanceCenter) *

           (EPbBalanceMaxRight-EPbBalanceMaxLeft) /

           (KMMFBalanceMaxRight-KMMFBalanceMaxLeft);

    }

LOCAL_C TInt MMFBalance(TInt aBalance)

    {

    return KMMFBalanceCenter+(KMMFBalanceMaxRight-KMMFBalanceMaxLeft)/

           (EPbBalanceMaxRight-EPbBalanceMaxLeft)*aBalance;

    }

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

// ----------------------------------------------------------------------------

// Two-phased constructor.

// ----------------------------------------------------------------------------

//

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

    {

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

    CleanupStack::PushL(p);

    p->ConstructL();

    CleanupStack::Pop(p);

    return p;

    }

// ----------------------------------------------------------------------------

// Symbian 2nd phase constructor can leave.

// ----------------------------------------------------------------------------

//

void CMPXLocalAudioPlayback::ConstructL()

    {

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

    iVolumeWatcher = CMPXCenRepWatcher::NewL(KCRUidMPXSettings,

                                             KMPXPlaybackVolume,

                                             this);

    iMuteWatcher = CMPXCenRepWatcher::NewL(KCRUidMPXSettings,

                                           KMPXPlaybackMute,

                                           this);

    iPlayer = CMdaAudioPlayerUtility::NewL(*this,

#ifdef __LOW_POWER_AUDIO_PLAYBACK

                        KAudioPriorityMusicPlayer,

                        TMdaPriorityPreference(KAudioPrefMusicLocalPlayback));

#else

#ifdef __HIGH_RESOLUTION_VOLUME

                        KAudioPriorityTwentyStepsVolumeMusicPlayer,

                        TMdaPriorityPreference(KAudioPrefTwentyStepsVolumeMusicPlayerPlayback));

#else

                        KAudioPriorityRealOnePlayer,

                        TMdaPriorityPreference(KAudioPrefRealOneLocalPlayback));

#endif // __HIGH_RESOLUTION_VOLUME

#endif // __LOW_POWER_AUDIO_PLAYBACK

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

    iFs.ShareProtected();

    iDrmMediaUtility = CMPXDrmMediaUtility::NewL();

    iAudioEffects = CMPXAudioEffectEngine::NewL( iPlayer );

    }

// ----------------------------------------------------------------------------

// C++ constructor

// ----------------------------------------------------------------------------

//

CMPXLocalAudioPlayback::CMPXLocalAudioPlayback()

	: iAudioEffectsOn(ETrue), iIsPlaying(EFalse)

    {}

// ----------------------------------------------------------------------------

// Destructor

// ----------------------------------------------------------------------------

//

CMPXLocalAudioPlayback::~CMPXLocalAudioPlayback()

    {

    MPX_FUNC_EX("CMPXLocalAudioPlayback::~CMPXLocalAudioPlayback");

    delete iMuteWatcher;

    delete iVolumeWatcher;

    if ( iDrmMediaUtility )

        {

        TRAP_IGNORE( ConsumeRightsL( ContentAccess::EStop ) );

        iDrmMediaUtility->Close();

        delete iDrmMediaUtility;

        }

    if( iAudioEffects )

        {

        iAudioEffects->DestroyAudioEffect();

        delete iAudioEffects;

        }

    if (iPlayer)

        {

        iPlayer->Close();

        delete iPlayer;

        }

    iFile.Close();

    iFs.Close();

    delete iSong;

    }

// ----------------------------------------------------------------------------

// Set observer

// ----------------------------------------------------------------------------

//

void CMPXLocalAudioPlayback::SetObserver(MMPXPlaybackPluginObserver& aObs)

    {

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

    iObs = &aObs;

    }

// ----------------------------------------------------------------------------

// Initializes a song for playback

// ----------------------------------------------------------------------------

//

void CMPXLocalAudioPlayback::InitialiseL(const TDesC& aSong)

    {

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

    iDrmMediaUtility->Close();

    delete iSong;

    iSong = NULL;

    iSong = aSong.AllocL();

    iFile.Close();

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

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

    // that is not existent

    if ( KErrNotReady == err )

        {

        err = KErrNotFound;

        }

    User::LeaveIfError( err );

#if defined(__HIGH_RESOLUTION_VOLUME)

    TParsePtrC parser(aSong);

    // Merlin twentysteps hack start

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

        {

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

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

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

        delete iAudioEffects;

        iAudioEffects = NULL;

        delete iPlayer;

        iPlayer = NULL;

        iPlayer = CMdaAudioPlayerUtility::NewL(*this,

                        KAudioPriorityRealOnePlayer,

                        TMdaPriorityPreference(KAudioPrefRealOneLocalPlayback));

        // Also regenerate audio effects

        iAudioEffects = CMPXAudioEffectEngine::NewL( iPlayer );

        }                        

    // Merlin twentysteps hack end

#endif // __HIGH_RESOLUTION_VOLUME

    TMMFileHandleSource source(iFile, KDefaultContentObject, EPlay);

    iPlayer->OpenFileL(source);

    iDrmMediaUtility->InitL( iFile );

    iState = EStateInitialising;

    iClosedByAudioPolicy = EFalse;

    iConsumeStarted = EFalse;

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

    }

// ----------------------------------------------------------------------------

// Initializes a song for playback

// ----------------------------------------------------------------------------

//

void CMPXLocalAudioPlayback::InitialiseL(RFile& aSong)

    {

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

    iDrmMediaUtility->Close();

    delete iSong;

    iSong = NULL;

    iSong = HBufC::NewL(KMaxFileName);

    TPtr ptr = iSong->Des();

    aSong.FullName(ptr);

#if defined(__HIGH_RESOLUTION_VOLUME)

    TParsePtrC parser(ptr);

    // Merlin twentysteps hack start

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

        {

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

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

        delete iAudioEffects;

        iAudioEffects = NULL;

        delete iPlayer;

        iPlayer = NULL;

        iPlayer = CMdaAudioPlayerUtility::NewL(*this,

                        KAudioPriorityRealOnePlayer,

                        TMdaPriorityPreference(KAudioPrefRealOneLocalPlayback));

        // Also regenerate audio effects

        iAudioEffects = CMPXAudioEffectEngine::NewL( iPlayer );

        }    

    // Merlin twentysteps hack end

#endif // __HIGH_RESOLUTION_VOLUME

    TMMFileHandleSource source(aSong, KDefaultContentObject, EPlay);

    iPlayer->OpenFileL(source);

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

    iDrmMediaUtility->InitL( iFile );

    iState = EStateInitialising;

    iClosedByAudioPolicy = EFalse;

    iConsumeStarted = EFalse;

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

    }

// ----------------------------------------------------------------------------

// Executes a command on the selected song

// ----------------------------------------------------------------------------

//

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

    {

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

    switch(aCmd)

        {

        case EPbCmdPlay:

            {

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

            // re-initialise the plugin first.

            if ( iClosedByAudioPolicy )

                {

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

                InitialiseL( *song );

                iConsumeStarted = ETrue;

                CleanupStack::PopAndDestroy( song );

                iClosedByAudioPolicy = EFalse;

                }

            else

                {

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

                TTimeIntervalMicroSeconds dur( iPlayer->Duration() );

                TTimeIntervalMicroSeconds pos( 0 );

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

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

                if ( !err &&

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

                     dur.Int64() > KPbMilliMultiplier )

                    {

                    MapcPlayComplete( KErrNone );

                    }

                else

                    {

                    if (iConsumeStarted)

                        {

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

                        if ( drmErr == KErrCANoRights )

                            {

                            iDrmMediaUtility->Close();

                            iPlayer->Stop();

                            iIsPlaying = EFalse;

                            iAudioEffects->DestroyAudioEffect();

                            iPlayer->Close();

                            iObs->HandlePluginEvent(

                                    MMPXPlaybackPluginObserver::EPStopped, 0,

                                    drmErr);

                            iFile.Close();

                            iState = EStateNotInitialised;

                            iObs->HandlePluginEvent(

                                    MMPXPlaybackPluginObserver::EPClosed,

                                    EPbCmdStop, drmErr);

                            iClosedByAudioPolicy = EFalse;

                            break;

                            }

                        }

                    else

                        {

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

                        if (AEErr == KErrDiskFull)

                        	{

                        	iDrmMediaUtility->Close();

				            iPlayer->Stop();

				            iIsPlaying = EFalse;

				            iAudioEffects->DestroyAudioEffect();

				            iPlayer->Close();

				            iObs->HandlePluginEvent(MMPXPlaybackPluginObserver::EPStopped,

				                    0, KErrDiskFull);

				            iFile.Close();

				            iState = EStateNotInitialised;

				            iObs->HandlePluginEvent(MMPXPlaybackPluginObserver::EPClosed,

				                                    EPbCmdStop, KErrDiskFull);

				            iClosedByAudioPolicy = EFalse;

				            break;

                        	}

                        iConsumeStarted = ETrue;

                        }

					if ( iAudioEffectsOn )

						{

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

						}

                    iPlayer->Play();

                    iIsPlaying = ETrue;

                    if( iAudioEffectsOn && err != KErrNone )

                        {

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

                        }

                    iObs->HandlePluginEvent(MMPXPlaybackPluginObserver::EPPlaying,

                                             0, KErrNone);

                    }

                }

            break;

            }

        case EPbCmdPause:

            {

            TRAP_IGNORE( ConsumeRightsL( ContentAccess::EPause ) );

            TInt err( iPlayer->Pause() );

            iIsPlaying = EFalse;

            iAudioEffects->DestroyAudioEffect();

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

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

            // state is correct.

            // This is for cases like playing .RNG files

            if ( KErrNotSupported == err )

                {

                iObs->HandlePluginEvent( MMPXPlaybackPluginObserver::EPPaused,

                                         0,

                                         KErrNone);

                iPlayer->Play();

                iIsPlaying = ETrue;

                iObs->HandlePluginEvent( MMPXPlaybackPluginObserver::EPPlaying,

                                         0,

                                         KErrNone);

                }

            else

                {

                iObs->HandlePluginEvent( MMPXPlaybackPluginObserver::EPPaused,

                                         0,

                                         err);

                }

            iClosedByAudioPolicy = EFalse;

            break;

            }

        case EPbCmdStop:

            {

            TRAP_IGNORE( ConsumeRightsL( ContentAccess::EStop ));

            iConsumeStarted = EFalse;

            iDrmMediaUtility->Close();

            iPlayer->Stop();

            iIsPlaying = EFalse;

            iAudioEffects->DestroyAudioEffect();

            iPlayer->Close();

            iObs->HandlePluginEvent(MMPXPlaybackPluginObserver::EPStopped,

                    0, KErrNone);

            iFile.Close();

            iState = EStateNotInitialised;

            iObs->HandlePluginEvent(MMPXPlaybackPluginObserver::EPClosed,

                                    EPbCmdStop, KErrNone);

            iClosedByAudioPolicy = EFalse;

            break;

            }

        case EPbCmdClose:

            {

            TRAP_IGNORE( ConsumeRightsL( ContentAccess::EStop ));

            iConsumeStarted = EFalse;

            iDrmMediaUtility->Close();

            iAudioEffects->DestroyAudioEffect();

            iPlayer->Close();

            iIsPlaying = EFalse;

            iFile.Close();

            iState = EStateNotInitialised;

            iObs->HandlePluginEvent(MMPXPlaybackPluginObserver::EPClosed,

                                    EPbCmdClose, KErrNone);

            iClosedByAudioPolicy = EFalse;

            break;

            }

        case EPbApplyEffect:

            {

            // Re-init audio effects

            MPX_DEBUG1("CMPXLocalAudioPlayback::CommandL EPbApplyEffect");

            iAudioEffects->DestroyAudioEffect();

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

                ( EStateInitialised == iState ) )

                {

                TRAPD(err, iAudioEffects->CreateAudioEffectsL() );

                if(err)

                    {

                    MPX_DEBUG2("EPbApplyEffect err = %d", err);

                    TRAPD(err, iAudioEffects->CreateAudioEffectsL() );

                    if(err)

                        {

                        MPX_DEBUG2("EPbApplyEffect again err = %d", err);

                        }

					else

						{

                        MPX_DEBUG1("EPbApplyEffect again set");

						}

                    }

				else

					{

                    MPX_DEBUG1("EPbApplyEffect set");

					}

                iAudioEffectsOn = ETrue;

                }

            break;

            }

        case EPbCmdCloseItem:

            {

            iDrmMediaUtility->Close();

            iPlayer->Close();

            iIsPlaying = EFalse;

            iFile.Close();

            iState = EStateNotInitialised;

            iClosedByAudioPolicy = EFalse;

            break;

            }

        case EPbCmdDisableEffect:

        	{

			iAudioEffectsOn = EFalse;

			break;

			}

		default:

			break;

        }

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

    }

// ----------------------------------------------------------------------------

// Sets a property of the plugin

// ----------------------------------------------------------------------------

//

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

    {

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

               this, aProperty, aValue);

    TBool isSupported=ETrue;

    switch(aProperty)

        {

        case EPbPropertyVolume:

            {

            break;

            }

        case EPbPropertyVolumeRamp:

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

            break;

        case EPbPropertyMute:

            break;

        case EPbPropertyBalance:

            iPlayer->SetBalance(MMFBalance(aValue));

            break;

        case EPbPropertyPosition:

            {

            TInt64 pos(aValue);

            pos *= KPbMilliMultiplier;

            if (iIsPlaying)

                {

                iPlayer->Pause();

                iPlayer->SetPosition(pos);

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

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

                if ( drmErr == KErrCANoRights )

                    {

                    iDrmMediaUtility->Close();

                    iPlayer->Stop();

                    iIsPlaying = EFalse;

                    iAudioEffects->DestroyAudioEffect();