/*

* 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 manages progress download

*

*/

// INCLUDE FILES

#include <f32plugin.h>

#include <AudioPreference.h>

#include <badesca.h>

#include <apgcli.h>

#include <mmf/common/mmfcontrollerframeworkbase.h>

#include <mmf/common/mmfmeta.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxmedia.h>

#include <mpxplaybackpluginobserver.h>

#include <mpxmediaaudiodefs.h>

#include <mpxmediamusicdefs.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediadrmdefs.h>

#include <mpxcmn.h>

#include <mpxdrmmediautility.h>

#include <mpxprivatecrkeys.h>

#include <mpxcenrepwatcher.h>

#include <mpxlog.h>

#include "mpxprogressdownload.h"

// CONSTANTS

const TUid KProgressDownloadUid={0x101FFC09};

const TInt KProgressPlayEndThreshold=8000000; // 8 seconds, in milliseconds

_LIT(KMMFMetaEntryAuthor, "author"); // For WMA progressive download

// ============================ 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.

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

//

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

    {

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

    CleanupStack::PushL(p);

    p->ConstructL();

    CleanupStack::Pop(p);

    return p;

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CMPXProgressDownload::ConstructL()

    {

    iVolumeWatcher = CMPXCenRepWatcher::NewL(KCRUidMPXSettings,

                                             KMPXPlaybackVolume,

                                             this);

    iMuteWatcher = CMPXCenRepWatcher::NewL(KCRUidMPXSettings,

                                           KMPXPlaybackMute,

                                           this);

    iFeatureFlag = EPbFeatureBalance | EPbFeatureVolumeRamp;

    iDrmMediaUtility = CMPXDrmMediaUtility::NewL();

    }

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

// C++ constructor

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

//

CMPXProgressDownload::CMPXProgressDownload()

    {}

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

// Destructor

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

//

CMPXProgressDownload::~CMPXProgressDownload()

    {

    delete iMuteWatcher;

    delete iVolumeWatcher;

    if ( iDrmMediaUtility )

        {

        if ( EPbDlStateDownloadCompleted == iDownloadState )

            {

            TRAP_IGNORE( ConsumeRightsL( ContentAccess::EStop ) );

            }

        delete iDrmMediaUtility;

        }

    if (iPdPlayer)

        {

        iPdPlayer->Close();

        iObs->HandlePluginEvent(MMPXPlaybackPluginObserver::EPActive,EFalse,KErrNone);

        delete iPdPlayer;

        }

    delete iPdUtil;

    delete iPdPath;

    }

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

// Initializes a song for playback

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

//

void CMPXProgressDownload::InitialiseL(const TDesC& aSong)

    {

    MPX_DEBUG2("CMPXProgressDownload::InitialiseL(%S) entering", &aSong );

    // Re-initialize ProgressiveDownloadUtility to make sure multiple sequential

    // downloads work

    delete iPdPlayer;

    iPdPlayer = NULL;

    delete iPdUtil;

    iPdUtil = NULL;

    iPdUtil = CProgressiveDownloadUtility::NewL();

    iPdPlayer = iPdUtil->OpenL( aSong, *this );

    delete iPdPath;

    iPdPath = NULL;

    iPdPath = aSong.AllocL();

    iDownloadState = EPbDlStateBuffering;

    iState = EStateInitialising;

    iConsumeStarted = EFalse;

    MPX_DEBUG1("CMPXProgressDownload::InitialiseL() exiting");

    }

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

// Initializes a song for playback

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

//

void CMPXProgressDownload::InitialiseL(RFile& aSong)

    {

    MPX_DEBUG1("CMPXProgressDownload::InitialiseL(RFile) entering");

    // Re-initialize ProgressiveDownloadUtility to make sure multiple sequential

    // downloads work

    delete iPdPlayer;

    iPdPlayer = NULL;

    delete iPdUtil;

    iPdUtil = NULL;

    iPdUtil = CProgressiveDownloadUtility::NewL();

    iPdPlayer = iPdUtil->OpenL( aSong, *this );

    delete iPdPath;

    iPdPath = NULL;

    TFileName filename;

    aSong.FullName(filename);

    iPdPath = filename.AllocL();

    iDownloadState = EPbDlStateBuffering;

    iState = EStateInitialising;

    iConsumeStarted = EFalse;

    MPX_DEBUG1("CMPXProgressDownload::InitialiseL() exiting");

    }

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

// Executes a command on the selected song

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

//

void CMPXProgressDownload::CommandL(TMPXPlaybackCommand aCmd, TInt /*aData*/)

    {

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

    if (iPdPlayer)

        {

        switch(aCmd)

            {

            case EPbCmdPlay:

                {

                if ( EPbDlStateDownloadCompleted == iDownloadState )

                    {

                    if (iConsumeStarted)

                        {

                        ConsumeRightsL( ContentAccess::EContinue );

                        }

                    else

                        {

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

                        if (AEErr == KErrDiskFull)

                        	{

                			iDrmMediaUtility->Close();

                			iPdPlayer->Close();

                			iState = EStateNotInitialised;

                			iDownloadState = EPbDlStateNotDownloading;

                			iObs->HandlePluginEvent(MMPXPlaybackPluginObserver::EPClosed,

                                         0, KErrDiskFull);

				            break;

                        	}

                        iConsumeStarted = ETrue;

                        }

                    }

                iPdPlayer->Play();

                iState = EStateInitialised;

                iObs->HandlePluginEvent(MMPXPlaybackPluginObserver::EPPlaying,

                                         0, KErrNone);

                break;

                }

            case EPbCmdPause:

                if ( EPbDlStateDownloadCompleted == iDownloadState && iConsumeStarted )

                    {

                    ConsumeRightsL( ContentAccess::EPause );

                    }

                iPdPlayer->Pause();

                iObs->HandlePluginEvent(MMPXPlaybackPluginObserver::EPPaused,

                                         0, KErrNone);

                break;

            case EPbCmdStop:

                if ( EPbDlStateDownloadCompleted == iDownloadState && iConsumeStarted )

                    {

                    ConsumeRightsL( ContentAccess::EStop );

                    iConsumeStarted = EFalse;

                    }

                iDrmMediaUtility->Close();

                iPdPlayer->Stop();

                iObs->HandlePluginEvent(MMPXPlaybackPluginObserver::EPStopped,

                                         0, KErrNone);

                break;

            case EPbCmdClose:

                if ( EPbDlStateDownloadCompleted == iDownloadState && iConsumeStarted )

                    {

                    ConsumeRightsL( ContentAccess::EStop );

                    iConsumeStarted = EFalse;

                    }

                iDrmMediaUtility->Close();

                iPdPlayer->Close();

                iState = EStateNotInitialised;

                iDownloadState = EPbDlStateNotDownloading;

                iObs->HandlePluginEvent(MMPXPlaybackPluginObserver::EPClosed,

                                         0, KErrNone);

                break;

            }

        }

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

    }

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

// Executes a command

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

//

void CMPXProgressDownload::CommandL( CMPXCommand& aCmd )

    {

    MPX_FUNC("CMPXProgressDownload::CommandL(CMPXCommand)");

    ASSERT( aCmd.IsSupported( KMPXCommandGeneralId ));

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

    if ( KMPXCommandIdPlaybackPD == id )

        {

        ASSERT(aCmd.IsSupported(KMPXCommandPlaybackGeneralType));

        TMPXPlaybackPdCommand cmd(

            static_cast<TMPXPlaybackPdCommand>(

                aCmd.ValueTObjectL<TInt>(KMPXCommandPlaybackGeneralType)));

        switch ( cmd )

            {

            case ( EPbCmdStartPd ):

                {

                ASSERT( aCmd.IsSupported( KMPXCommandPlaybackPDTransactionID ));

                iTransactionId = aCmd.ValueTObjectL<TUint>( KMPXCommandPlaybackPDTransactionID );

                break;

                }

            case ( EPbCmdFinishPd ):

                {

                iObs->HandlePluginEvent(

                        MMPXPlaybackPluginObserver::EPPlayComplete,

                        0,

                        KErrNone);

                break;

                }

            case ( EPbCmdHandlePdEvent ):

                {

                ASSERT( aCmd.IsSupported( KMPXCommandPlaybackPDTransactionID ) &&

                        aCmd.IsSupported( KMPXCommandPlaybackPDEvent ) &&

                        aCmd.IsSupported( KMPXCommandPlaybackGeneralData ));

                TUint transId( aCmd.ValueTObjectL<TUint>( KMPXCommandPlaybackPDTransactionID ));

                TBrCtlDownloadEvent event(

                    aCmd.ValueTObjectL<TBrCtlDownloadEvent>( KMPXCommandPlaybackPDEvent ));

                TUint val( aCmd.ValueTObjectL<TUint>( KMPXCommandPlaybackGeneralData ));

                HandleDownloadEventL( transId, event, val );

                break;

                }

            case ( EPbCmdGetPdStatus ):

                {

                aCmd.SetTObjectValueL<TUint>(

                        KMPXCommandPlaybackPDTransactionID,

                        iTransactionId );

                aCmd.SetTObjectValueL<TMPXPlaybackPdDownloadState>(

                        KMPXCommandPlaybackPDState,

                        static_cast<TMPXPlaybackPdDownloadState>(iDownloadState));

                aCmd.SetTObjectValueL<TInt>(

                        KMPXCommandPlaybackPDDownloadedBytes,

                        iDownloadBytes );

                aCmd.SetTObjectValueL<TInt>(

                        KMPXCommandPlaybackPDTotalBytes,

                        iDownloadSize );

                break;

                }

            case ( EPbCmdPausePd ):

                {

                iObs->HandlePluginEvent(

                        MMPXPlaybackPluginObserver::EPDownloadCmdPauseDownload,

                        iTransactionId,

                        KErrNone );

                break;

                }

            case ( EPbCmdResumePd ):

                {

                iObs->HandlePluginEvent(

                        MMPXPlaybackPluginObserver::EPDownloadCmdResumeDownload,

                        iTransactionId,

                        KErrNone );

                break;

                }

            case ( EPbCmdCancelPd ):

                {

                iObs->HandlePluginEvent(

                        MMPXPlaybackPluginObserver::EPDownloadCmdCancelDownload,

                        iTransactionId,

                        KErrNone);

                break;

                }

            default:

                break;

            }

        }

    }

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

// Sets a property of the plugin

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

//

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

    {

    MPX_DEBUG3("CMPXProgressDownload::SetL(%d, %d) entering", aProperty, aValue);

    TBool isSupported=ETrue;

    switch(aProperty)

        {

        case EPbPropertyVolume:

            {

            SetVolume( aValue );

            break;

            }

        case EPbPropertyVolumeRamp:

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

            break;

        case EPbPropertyMute:

            SetMute( aValue );

            break;

        case EPbPropertyBalance:

            iPdPlayer->SetBalance(MMFBalance(aValue));

            break;

        case EPbPropertyPosition:

            {

            TInt64 pos(aValue);

            pos *= KPbMilliMultiplier;

            iPdPlayer->SetPosition(pos);

            }

            break;

        default:

            isSupported=EFalse;

        }

    if (!isSupported)

        {

        User::Leave(KErrNotSupported);

        }

    iObs->HandlePluginEvent(MMPXPlaybackPluginObserver::EPSetComplete,

                             aProperty, KErrNone);

    MPX_DEBUG1("CMPXProgressDownload::SetL() exiting");

    }

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

// Gets a property of the plugin (async)

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

//

void CMPXProgressDownload::PropertyL(TMPXPlaybackProperty aProperty) const

    {

    MPX_DEBUG2("CMPXProgressDownload::ValueL(%d) entering", aProperty);

    TBool isSupported=ETrue;

    TInt value=KErrNotFound;

    TInt err(KErrNone);

    switch(aProperty)

        {

        case EPbPropertyVolume:

            {

            value = iVolumeWatcher->CurrentValueL();

            break;

            }

        case EPbPropertyMaxVolume:

            value=iPdPlayer->MaxVolume();

            break;

        case EPbPropertyMute:

            value = iMuteWatcher->CurrentValueL();

            break;

        case EPbPropertyBalance:

            err = iPdPlayer->GetBalance(value);

            value=Balance(value);

            break;

        case EPbPropertyDuration:

            {

            TTimeIntervalMicroSeconds duration = iPdPlayer->Duration();

            value = duration.Int64() / KPbMilliMultiplier;

            }

            break;

        case EPbPropertyPosition:

            {

            TTimeIntervalMicroSeconds pos;

            iPdPlayer->GetPosition(pos);

            value = pos.Int64() / KPbMilliMultiplier;

            }

            break;

        case EPbPropertySupportedFeatures:

            value = iFeatureFlag;

            break;

        default:

            isSupported=EFalse;

        }

    if (!isSupported)

        {

        User::Leave(KErrNotSupported);

        }

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

    MPX_DEBUG1("CMPXProgressDownload::ValueL() exiting");

    }

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

// Gets a list of sub players, UPnP only

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

//

void CMPXProgressDownload::SubPlayerNamesL()

    {

    iObs->HandleSubPlayerNames(KProgressDownloadUid, NULL, ETrue, KErrNone);

    }

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

// Select a sub player

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

//

void CMPXProgressDownload::SelectSubPlayerL(TInt /*aIndex*/)

    {

    User::Leave(KErrNotSupported);

    }

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

// Returns current sub player name

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

//

const TDesC& CMPXProgressDownload::SubPlayerName()

    {

    return KNullDesC; //No subplayer name for local playback

    }

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

// Current sub player index

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

//

TInt CMPXProgressDownload::SubPlayerIndex() const

   {

   return KErrNotFound;

   }

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

// Gets media properties

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

//

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

    {

    MPX_DEBUG1("CMPXProgressDownload::MediaL() entering");

    RArray<TInt> suppIds;

    CleanupClosePushL(suppIds);

    suppIds.AppendL(KMPXMediaIdMusic);

    suppIds.AppendL(KMPXMediaIdGeneral);

    suppIds.AppendL(KMPXMediaIdAudio);

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

    CleanupStack::PopAndDestroy(&suppIds);

    CleanupStack::PushL(media);

    TUint attrG(0); // General attributes

    TUint attrA(0); // Audio attributes

    TUint attrM(0); // Music attributes

    TUint attrD(0); // DRM attributes

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

        {

        TMPXAttribute attr(aAttrs[i]);

        if (attr.ContentId() == KMPXMediaIdGeneral)

            {

            attrG |= attr.AttributeId();

            }

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

            {

            attrM |= attr.AttributeId();

            }

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

            {

            attrA |= attr.AttributeId();

            }

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