/*

* 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:  Controls playback via plug-ins

*

*/

#include <featmgr.h>

#include <mpxprivatecrkeys.h>

#include <mpxlog.h>

#include <mpxtaskqueue.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediamusicdefs.h>

#include <mpxmedia.h>

#include <mpxcommonframeworkdefs.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxplaybackcommanddefs.h>

#include <mpxcollectionpath.h>

#include <mpxattributespecs.h>

#include <mpxmessagepluginupdatedefs.h>

#include <mpxplaybackpluginversion2.h>

#include <mpxcmn.h>

#include <caf/caferr.h>

#include <mpxmediageneralextdefs.h>

#include "mpxplaybacksettings.h"

#include "mpxautoresumehandler.h"

#include "mpxplaybackcommandbuffer.h"

#include "mpxplaybackactiveengineobserver.h"

#include "mpxplaybackinitializer.h"

#include "mpxplaybackengine.h"

#include "mpxplaybackmediahelper.h"

#include "mpxplaybackdummymediaobserver.h"

// CONSTANTS

const TInt KMPXSmallVolumeIncrement = 5;

const TInt KMPXLargeVolumeIncrement = 10;

const TInt KPercentMultiplier = 100;

_LIT(KWmaExtension, ".wma");

_LIT(KRaExtension, ".ra");

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

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

// Two-phased constructor.

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

//

EXPORT_C CMPXPlaybackEngine* CMPXPlaybackEngine::NewL(

    CMPXPluginMonitor& aPluginMonitor,

    MMPXPlaybackActiveEngineObserver& aObserver,

    MMPXClientlistObserver* aClientListObserver,

    const TUid& aModeId)

    {

    CMPXPlaybackEngine* p=new(ELeave)CMPXPlaybackEngine(aPluginMonitor,

                                                        aObserver, aModeId);

    CleanupStack::PushL(p);

    p->ConstructL(aClientListObserver);

    CleanupStack::Pop(p);

    return p;

    }

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

// Two-phased constructor.

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

//

EXPORT_C CMPXPlaybackEngine* CMPXPlaybackEngine::NewL(

    CMPXPluginMonitor& aPluginMonitor,

    MMPXPlaybackActiveEngineObserver& aObserver,

    MMPXClientlistObserver* aClientListObserver,

    const TUid& aModeId,

    const TInt aCategory)

    {

    CMPXPlaybackEngine* p=new(ELeave)CMPXPlaybackEngine(aPluginMonitor,

                                                        aObserver, aModeId, aCategory);

    CleanupStack::PushL(p);

    p->ConstructL(aClientListObserver);

    CleanupStack::Pop(p);

    return p;

    }

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

// Constructor.

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

//

CMPXPlaybackEngine::CMPXPlaybackEngine(

    CMPXPluginMonitor& aPluginMonitor,

    MMPXPlaybackActiveEngineObserver& aObserver,

    const TUid& aModeId)

:   iReflector(*this),

    iPluginMonitor(aPluginMonitor),

    iItemId(KMPXInvalidItemId),

    iPlaySource(EPlayNone),

    iAccessPoint(0),

    iAccessPointSet(EFalse),

    iState(EPbStateNotInitialised),

    iNextState(EPbStateNotInitialised),

    iPluginState(EPbStateNotInitialised),

    iModeId(aModeId),

    iObserver(aObserver),

    iPreservedState( EPbStateNotInitialised ),

    iPreservedPosition( KErrNotFound ),

    iSkipping(EFalse),

    iPluginUid(KNullUid),

    iLastActiveProcess(KNullProcessId),

    iLastInactiveProcess(KNullProcessId)

    {

    iProperties[EPbPropertyVolumeRamp]=KPbFadeInDurationMicroSeconds;

    }

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

// Constructor.

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

//

CMPXPlaybackEngine::CMPXPlaybackEngine(

    CMPXPluginMonitor& aPluginMonitor,

    MMPXPlaybackActiveEngineObserver& aObserver,

    const TUid& aModeId,

    const TInt aCategory)

:   iReflector(*this),

    iPluginMonitor(aPluginMonitor),

    iItemId(KMPXInvalidItemId),

    iPlaySource(EPlayNone),

    iAccessPoint(0),

    iAccessPointSet(EFalse),

    iState(EPbStateNotInitialised),

    iNextState(EPbStateNotInitialised),

    iPluginState(EPbStateNotInitialised),

    iModeId(aModeId),

    iObserver(aObserver),

    iPreservedState( EPbStateNotInitialised ),

    iPreservedPosition( KErrNotFound ),

    iSkipping(EFalse),

    iPluginUid(KNullUid),

    iLastActiveProcess(KNullProcessId),

    iLastInactiveProcess(KNullProcessId),

    iCategory(aCategory)

    {

    iProperties[EPbPropertyVolumeRamp]=KPbFadeInDurationMicroSeconds;

    }

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

// 2nd phase constructor.

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

//

void CMPXPlaybackEngine::ConstructL(MMPXClientlistObserver* aClientListObserver)

    {

    MPX_FUNC_EX("CMPXPlaybackEngine::ConstructL");

    iClientList=CMPXClientList::NewL(aClientListObserver);

    iPluginHandler=CMPXPlaybackPluginHandler::NewL(iPluginMonitor, *this, *this);

    iCmdBuffer=CMPXPlaybackCmdBuffer::NewL(*this);

    iProgressTimer=CHeartbeat::NewL(CActive::EPriorityStandard);

    iSeekTimer=CPeriodic::NewL(CActive::EPriorityStandard);

    iAccessoryObs=CMPXAccessoryObserver::NewL(*this);

    iAutoResumeHandler = CMPXAutoResumeHandler::NewL(*this, EFalse);

    iPlaybackSettings = CMPXPlaybackSettings::NewL();

    iTaskQueue = CMPXActiveTaskQueue::NewL();

    FeatureManager::InitializeLibL();

#if defined(__HIGH_RESOLUTION_VOLUME)

    // Intialise volume level increment based on the accessory plugged in.

    SetVolumeIncrement( iAccessoryObs->AccessoryModeL() );

#else

    iVolumeIncrement = KMPXLargeVolumeIncrement;

#endif

    iMediaHelper = CMPXPlaybackMediaHelper::NewL( *this );

    iDummyMediaObserver = new(ELeave) CMPXPlaybackDummyMediaObserver();

    // Select local plugin by default if none selected

    iPluginHandler->SelectPlayersL( EPbLocal );

    iInitVolume = ETrue;

#if defined(__HIGH_RESOLUTION_VOLUME)

    iVolRoundedUp = EFalse;

#endif

    iPluginHandler->Plugin()->PropertyL( EPbPropertyVolume );

    }

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

// Destructor

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

//

EXPORT_C CMPXPlaybackEngine::~CMPXPlaybackEngine()

    {

    MPX_FUNC_EX("CMPXPlaybackEngine::~CMPXPlaybackEngine");

    if (iPluginHandler->Plugin())

        {

        iPluginHandler->Plugin()->CancelRequest();

        }

    DoClose();

    if (iTaskQueue)

        {

        delete iTaskQueue;

        }

    if (iProgressTimer)

        {

        delete iProgressTimer;

        }

    if (iSeekTimer)

        {

        delete iSeekTimer;

        }

    FeatureManager::UnInitializeLib();

    iFile.Close();

    delete iCmdBuffer;

    delete iAccessoryObs;

    delete iAutoResumeHandler;

    delete iPluginHandler;

    delete iClientList;

    delete iPlaybackSettings;

    delete iInitializer;

    iMediaAttrs.Close();

    delete iMediaHelper;

    delete iDummyMediaObserver;

#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

    iFile64.Close();

#endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

    }

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

// Initialises from collection

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

//

EXPORT_C void CMPXPlaybackEngine::InitL(

    const CMPXCollectionPlaylist& aPlaylist,

    TBool aPlay )

    {

    MPX_FUNC_EX("CMPXPlaybackEngine::InitL");

    iPluginUid = KNullUid; // Reset plugin uid for current item

    iInitNext = aPlaylist.PreInitPlugin();

    if ( iInitNext )

        {

        if ( !iInitializer )

            {

            iInitializer=CMPXPlaybackInitializer::NewL(*this, *iMediaHelper);

            }

        iInitializer->Close();

        }

    HandleCloseL();

    iPlaySource=EPlayFromCollection;

    iPlaylist=CMPXCollectionPlaylist::NewL(aPlaylist, this);

    CMPXCollectionPlaylist::TRepeatMode repeatmode =

            static_cast<CMPXCollectionPlaylist::TRepeatMode>(

                    iProperties[EPbPropertyRepeatMode]);

    iPlaylist->SetRepeatMode(repeatmode);

    // if current index is not 0, play the selected item, otherwise play any one

    iPlaylist->SetShuffleL(iProperties[EPbPropertyRandomMode],

                           iPlaylist->Index()!=-1);

    iSkipping = EFalse;

    if ( aPlay )

        {

        if ( iPlaylist->Count() > 0 )

            {

            iNextState=EPbStateNotInitialised;

            MediaFromCollectionL();

            }

        }

    else

        {

        if ( iPlaylist->Count() > 0 )

            {

            iState = EPbStateStopped;

            }

        else

            {

            iState = EPbStateNotInitialised;

            }

        iAutoResumeHandler->HandlePlaybackStateChange(iState);

        iClientList->SendMsgL(

            TMPXPlaybackMessage(TMPXPlaybackMessage::EStateChanged,iState));

        iNextState = iState;

        //update now playing view

        iClientList->SendMsgL(TMPXPlaybackMessage(

                TMPXPlaybackMessage::EPlaylistUpdated));

        iClientList->SendMsgL(

            TMPXPlaybackMessage(

                TMPXPlaybackMessage::EInitializeComplete,

                0,

                EFalse));

        iPluginUid = iPluginHandler->Plugin()->Uid();

        RArray<TMPXAttribute> dummy;

        CleanupClosePushL( dummy );

        dummy.AppendL( KMPXMediaGeneralUri ); // dummy attribute to get

        iPlaylist->MediaL( dummy.Array(), *iDummyMediaObserver);

        CleanupStack::PopAndDestroy( &dummy );

        }

    }

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

// Initialises from URI

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

//

EXPORT_C void CMPXPlaybackEngine::InitL(const TDesC& aUri,const TDesC8& aType)

    {

    MPX_FUNC_EX("CMPXPlaybackEngine::InitL(const TDesC& aUri,const TDesC8& aType)");

    MPX_DEBUG2("CMPXPlaybackEngine::InitL(%S)", &aUri);

    iPluginUid = KNullUid; // Reset plugin uid for current item

    iInitNext=EFalse;

    HandleCloseL();

    iPlaySource=EPlayFromUri;

    iNextState=EPbStateNotInitialised;

    delete iUri;

    iUri = NULL;

    iUri=aUri.AllocL();

    iItemId = KMPXInvalidItemId;

    TRAPD( err, InitL(&aUri,&aType,NULL) );

    if ( KErrNotFound == err || KErrPathNotFound == err )

        {

        // Mark item as Invalid

        MarkItemInvalid( ETrue );

        User::Leave( err );

        }

    }

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

// Initialises from file.

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

//

EXPORT_C void CMPXPlaybackEngine::InitL(const RFile& aFile)

    {

    MPX_FUNC_EX("CMPXPlaybackEngine::InitL(const RFile& aFile)");

    iPluginUid = KNullUid; // Reset plugin uid for current item

    iInitNext=EFalse;

    HandleCloseL();

    iPlaySource=EPlayFromFile;

    iNextState=EPbStateNotInitialised;

    iFile.Duplicate(aFile);

    TRAPD( err, InitL(NULL,NULL,&iFile) );

    if ( KErrNotFound == err )

        {

        // Mark item as Invalid

        MarkItemInvalid( ETrue );

        User::Leave( err );

        }

    }

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

// Initialises from URI

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

//

EXPORT_C void CMPXPlaybackEngine::InitStreamingL(const TDesC& aUri, const TDesC8& aType, const TInt aAccessPoint)

    {

    MPX_FUNC_EX("CMPXPlaybackEngine::InitStreamingL(const TDesC& aUri, const TInt aAccessPoint)");

    MPX_DEBUG4("CMPXPlaybackEngine::InitStreamingL(%S), (%s), (%d)", &aUri, &aType, aAccessPoint);

    iPluginUid = KNullUid; // Reset plugin uid for current item

    iInitNext=EFalse;

    HandleCloseL();

    iPlaySource=EPlayFromUri;

    iNextState=EPbStateNotInitialised;

    delete iUri;

    iUri = NULL;

    iUri=aUri.AllocL();

    iItemId = KMPXInvalidItemId;

    iAccessPoint = aAccessPoint;

    iAccessPointSet = ETrue;

    TRAPD( err, InitL(&aUri,&aType,NULL,aAccessPoint) );

    if ( KErrNotFound == err || KErrPathNotFound == err )

        {

        // Mark item as Invalid

        MarkItemInvalid( ETrue );

        User::Leave( err );

        }

    }

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

// Initialises from file.

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

//

EXPORT_C void CMPXPlaybackEngine::InitStreamingL(const RFile& aFile, const TInt aAccessPoint)

    {

    MPX_FUNC_EX("CMPXPlaybackEngine::InitStreamingL(const RFile& aFile, const TInt aAccessPoint)");

    iPluginUid = KNullUid; // Reset plugin uid for current item

    iInitNext=EFalse;

    HandleCloseL();

    iPlaySource=EPlayFromFile;

    iNextState=EPbStateNotInitialised;

    iFile.Duplicate(aFile);

    iAccessPoint = aAccessPoint;

    iAccessPointSet = ETrue;

    TRAPD( err, InitL(NULL,NULL,&iFile,aAccessPoint));

    if ( KErrNotFound == err )

        {

        // Mark item as Invalid

        MarkItemInvalid( ETrue );

        User::Leave( err );

        }

    }

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

// Cancels all outsatnding calls (tasks): plug-in should only have one

// outstanding so that is canceled; the tasks are deleted and removed from the

//  queue

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

//

EXPORT_C void CMPXPlaybackEngine::CancelRequests()

    {

    MPX_FUNC_EX("CMPXPlaybackEngine::CancelRequests()");

    CMPXPlaybackPlugin* p(iPluginHandler->Plugin());

    if (iCallback && iTaskQueue->PtrData())

        { // there is outstanding request

        p = static_cast<CMPXPlaybackPlugin*>(iTaskQueue->PtrData());

        }

    if (p)

        {

        p->CancelRequest();

        if (iCallback)

            {

            iTaskQueue->CompleteTask();

            iCallback = NULL;

            }

        }

    if (iPlaylist)

        {

        iPlaylist->CancelRequest();

        }

    if (iInitializer)

        {

        iInitializer->Close();

        }

    iTaskQueue->CancelRequests();

    iMediaHelper->CancelRequests();

    }

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

// Handle a command

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

//

EXPORT_C void CMPXPlaybackEngine::CommandL(TMPXPlaybackCommand aCmd,

                                           TInt aData)

    {

    MPX_DEBUG2("CMPXPlaybackEngine::CommandL(%d) entering", aCmd);

    iClientList->SendMsgL(TMPXPlaybackMessage(

                            TMPXPlaybackMessage::ECommandReceived,

                            aCmd,

                            0));

    if (iCmdBuffer->CommandForBuffering(aCmd))

        {

        // Buffered commands are not valid if there are no items in playlist

        TBool cmdOK( ETrue );

        if ( iPlaySource == EPlayFromCollection )

            {

            if ( iPlaylist )

                {

                cmdOK = ( iPlaylist->Count() > 0 );

                }

            else

                {

                cmdOK = EFalse;

                }

            }

        if ( cmdOK )

            {

            iCmdBuffer->BufferCommandL(aCmd,iNextState,

                                       iProperties[EPbPropertyPosition]);

            }

        }

    else

        {

        HandleCommandL(aCmd,aData);

        }

    MPX_DEBUG1("CMPXPlaybackEngine::CommandL() exiting");

    }

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

// Handle a command

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

//

EXPORT_C void CMPXPlaybackEngine::CommandL(

    CMPXCommand& aCmd,

    const CMPXMessageQueue& aMsgQueue )

    {

    MPX_FUNC_EX("CMPXPlaybackEngine::CommandL(CMPXCommand& aCmd)");

    ASSERT(aCmd.IsSupported(KMPXCommandGeneralId));

    TInt id = aCmd.ValueTObjectL<TInt>(KMPXCommandGeneralId);

    switch (id)

        {

        case KMPXCommandIdPlaybackGeneral:

            {

            ASSERT(aCmd.IsSupported(KMPXCommandPlaybackGeneralType));

            TMPXPlaybackCommand cmd = static_cast<TMPXPlaybackCommand>(

                        aCmd.ValueTObjectL<TInt>(KMPXCommandPlaybackGeneralType));

            if ( EPbCmdPlay == cmd ||

                    EPbCmdPlayPause == cmd ||

                    EPbCmdStop == cmd)

                {

                ASSERT(aCmd.IsSupported(KMPXCommandPlaybackGeneralClientPid));

                iLastActiveProcess = aCmd.ValueTObjectL<TProcessId>(

                                           KMPXCommandPlaybackGeneralClientPid);

                }

            else if (EPbCmdStop == cmd)

                {

                ASSERT(aCmd.IsSupported(KMPXCommandPlaybackGeneralClientPid));

                iLastInactiveProcess = aCmd.ValueTObjectL<TProcessId>(

                                           KMPXCommandPlaybackGeneralClientPid);

                }

            TInt data(0);

            if (aCmd.IsSupported(KMPXCommandPlaybackGeneralData))

                {