/*

* 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 using Enhanced Media

                 Client API

*

*/

// INCLUDE FILES

#include <f32plugin.h>

#include <AudioPreference.h>

#include <badesca.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 <pathinfo.h>

#include <mmf/common/mmfdrmcustomcommands.h>

#include <MetaDataUtility.h>

#include <MetaDataFieldContainer.h>

#include <MMControlFactory.h>

using namespace multimedia;

#include "mpxprogressdownloadsb.h"

// CONSTANTS

const TUid KProgressDownloadUid={0x10207BCD};

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

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

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

// Two-phased constructor.

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

//

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

    {

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

    CleanupStack::PushL(p);

    p->ConstructL();

    CleanupStack::Pop(p);

    return p;

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CMPXProgressDownloadSB::ConstructL()

    {

    iVolumeWatcher = CMPXCenRepWatcher::NewL(KCRUidMPXSettings,

                                             KMPXPlaybackVolume,

                                             this);

    iMuteWatcher = CMPXCenRepWatcher::NewL(KCRUidMPXSettings,

                                           KMPXPlaybackMute,

                                           this);

    iFeatureFlag = EPbFeatureBalance | EPbFeatureVolumeRamp;

    iDrmMediaUtility = CMPXDrmMediaUtility::NewL();

    //Create Factory

    TInt status = CMultimediaFactory::CreateFactory( iFactory );

    User::LeaveIfError(status);

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

    }

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

// C++ constructor

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

//

CMPXProgressDownloadSB::CMPXProgressDownloadSB()

    : iStreamBuffering(EFalse),

      iFirstBuffer(EFalse),

      iFileSaved(EFalse),

      iDownloadBytes(0),

      iDownloadSize(0),

      iFileHandle(NULL),

      iPdPath(NULL),

      iPlaying(EFalse),

      iOngoingCmdCancelDownload(EFalse),

      iErrorOfStreamClosedEvent(KErrNone)

    {}

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

// Destructor

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

//

CMPXProgressDownloadSB::~CMPXProgressDownloadSB()

    {

    delete iMuteWatcher;

    delete iVolumeWatcher;

    if ( iDrmMediaUtility )

        {

        if ( EPbDlStateDownloadCompleted == iDownloadState )

            {

            ConsumeRights( ContentAccess::EStop );

            }

        iDrmMediaUtility->Close();

        delete iDrmMediaUtility;

        iDrmMediaUtility = NULL;

        }

    ResetEnhancedMediaClient();

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

    delete iFactory;

    iFactory = NULL;

    delete iPdPath;

    delete iDrmCustomCommand;

    iDrmCustomCommand = NULL;

    iFs.Close();

    }

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

// Destructor

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

//

void CMPXProgressDownloadSB::ResetEnhancedMediaClient()

    {

    if (iMStreamControl)

        {

        iMStreamControl->Close();

        }

    if (iMAudioProgDLSource)

        {

        iMAudioProgDLSource->Close();

        }

    if(iFactory)

        {

        if(iMStreamControl)

            {

            iFactory->DeleteStreamControl(iMStreamControl);

            iMStreamControl = NULL;

            }

        if(iMAudioProgDLSource)

           {

           MSourceControl* objPtr = iMAudioProgDLSource;

           iFactory->DeleteSourceControl(objPtr);

           iMAudioProgDLSource = NULL;

           }

        if(iMAudioSink)

            {

            MSinkControl* objPtr = iMAudioSink;

            iFactory->DeleteSinkControl(objPtr);

            iMAudioSink = NULL;

            }

        if(iMVolumeControl)

            {

            MEffectControl* effectObj = iMVolumeControl;

            iFactory->DeleteEffectControl(effectObj);

            iMVolumeControl = NULL;

            }

        }

    }

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

// Initializes a song for playback

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

//

void CMPXProgressDownloadSB::InitialiseL(const TDesC& aSong)

    {

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

    // Re-initializes EMC to make sure multiple sequential

    // downloads work

    ResetEnhancedMediaClient();

    //Create Stream Source

    TInt err = iFactory->CreateStreamControl( KStreamControl, iMStreamControl );

    User::LeaveIfError(err);

    iMStreamControl->AddObserver( *this );

    //Create PD Source

    if ( iMStreamControl == NULL )

        {

        User::Leave(KErrNotReady);

        }

    if ( iMAudioProgDLSource != NULL )

        {

        User::Leave(KErrAlreadyExists);

        }

    MSourceControl* tempCtrl(NULL);

    err = iFactory->CreateSourceControl( KProgDLSourceControl, tempCtrl );

    User::LeaveIfError(err);

    iMAudioProgDLSource = static_cast<MProgDLSource*>(tempCtrl);

    //Open PDL Source

    err = iMAudioProgDLSource->Open(aSong, iTransactionId);

    User::LeaveIfError(err);

    err = iMAudioProgDLSource->AddObserver( *this );

     User::LeaveIfError(err);

    err = iMStreamControl->AddSource( *iMAudioProgDLSource );

    User::LeaveIfError(err);

    //Create Sink

    MSinkControl* tempSinkCtrl(NULL);

    err = iFactory->CreateSinkControl( KMMFAudioOutputSinkControl, tempSinkCtrl );

    User::LeaveIfError(err);

    iMAudioSink = tempSinkCtrl;

    iMStreamControl->AddSink( *iMAudioSink );

    //Create Volume Control

    MEffectControl* effectCtrl(NULL);

    err = iFactory->CreateEffectControl( KVolumeEffectControl, effectCtrl );

    User::LeaveIfError(err);

    iMVolumeControl = static_cast<MVolumeControl*>(effectCtrl);

    err = iMStreamControl->AddEffect( *iMVolumeControl );

    //Open Stream

    iMStreamControl->SetPriority( KAudioPriorityRealOnePlayer, KAudioPrefRealOneLocalPlayback );

    err =  iMStreamControl->Open();

    User::LeaveIfError(err);

    iStreamBuffering = ETrue;

    delete iPdPath;

    iPdPath = NULL;

    iPdPath = aSong.AllocL();

    iDownloadState = EPbDlStateBuffering;

    iState = EStateInitialising;

    iConsumeStarted = EFalse;

    iFileSaved = EFalse;

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

    }

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

// Initializes a song for playback

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

//

void CMPXProgressDownloadSB::InitialiseL(RFile& /*aSong*/)

    {

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

    User::Leave(KErrNotSupported);

    }

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

// Executes a command on the selected song

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

//

void CMPXProgressDownloadSB::CommandL(

    TMPXPlaybackCommand aCmd,

    TInt /*aData*/)

    {

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

    if ( iMStreamControl )

        {

        switch( aCmd )

            {

            case EPbCmdPlay:

                {

                if ( EPbDlStateDownloadCompleted == iDownloadState )

                    {

                    if ( iConsumeStarted )

                        {

                        ConsumeRights( ContentAccess::EContinue );

                        }

                    else

                        {

                        ConsumeRights( ContentAccess::EPlay );

                        iConsumeStarted = ETrue;

                        }

                    iMStreamControl->Start();

                    }

                if ( iMStreamControl->GetState() == MStreamControl::EXECUTING )

                    {

                    iObs->HandlePluginEvent(MMPXPlaybackPluginObserver::EPPlaying,

                                             0, KErrNone);

                    }

                else

                    {

                    iMStreamControl->Start();

                    }

                break;

                }

            case EPbCmdPause:

                if ( EPbDlStateDownloadCompleted == iDownloadState && iConsumeStarted )

                    {

                    ConsumeRights( ContentAccess::EPause );

                    }

                TInt ret = iMStreamControl->Pause();

                iObs->HandlePluginEvent(MMPXPlaybackPluginObserver::EPPaused, 0, ret);

                break;

            case EPbCmdStop:

                iMStreamControl->Stop();

                iObs->HandlePluginEvent(MMPXPlaybackPluginObserver::EPStopped,

                                         0, KErrNone);

                if ( EPbDlStateDownloadCompleted == iDownloadState && iConsumeStarted )

                    {

                    ConsumeRights( ContentAccess::EStop );

                    iConsumeStarted = EFalse;

                    if ( !iFileSaved )

                        {

                        iDrmMediaUtility->Close(); // release file handle so we can move file.

                        MoveDownloadedFileToMusicFolderL();

                        }

                    }

                iDrmMediaUtility->Close();

                break;

            case EPbCmdClose:

                if ( EPbDlStateDownloadCompleted == iDownloadState && iConsumeStarted  )

                    {

                    ConsumeRights( ContentAccess::EStop );

                    iConsumeStarted = EFalse;

                    if ( !iFileSaved )

                        {

                        iDrmMediaUtility->Close(); // release file handle so we can move file.

                        MoveDownloadedFileToMusicFolderL();

                        }

                    }

                iDrmMediaUtility->Close();

                iState = EStateNotInitialised;

                iDownloadState = EPbDlStateNotDownloading;

                iObs->HandlePluginEvent(MMPXPlaybackPluginObserver::EPClosed,

                                         0, KErrNone);

                break;

            }

        }

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

    }

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

// Executes a command

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

//

void CMPXProgressDownloadSB::CommandL( CMPXCommand& aCmd )

    {

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

    ASSERT( aCmd.IsSupported( KMPXCommandGeneralId ));

    TInt id( *aCmd.Value<TInt>( KMPXCommandGeneralId ));

    if ( KMPXCommandIdPlaybackPD == id )

        {

        ASSERT(aCmd.IsSupported(KMPXCommandPlaybackGeneralType));

        TMPXPlaybackPdCommand cmd(

            static_cast<TMPXPlaybackPdCommand>(

                *aCmd.Value<TInt>(KMPXCommandPlaybackGeneralType)));

        switch ( cmd )

            {

            case ( EPbCmdStartPd ):

                {

                ASSERT( aCmd.IsSupported( KMPXCommandPlaybackPDTransactionID ));

                iTransactionId = *aCmd.Value<TUint>( KMPXCommandPlaybackPDTransactionID );

                break;

                }

            case ( EPbCmdFinishPd ):

                {

                iObs->HandlePluginEvent( MMPXPlaybackPluginObserver::EPPlayComplete,

                                         0,KErrNone);

                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 ):

                {

                iMAudioProgDLSource->ResumeDownload();

                iObs->HandlePluginEvent(

                        MMPXPlaybackPluginObserver::EPDownloadCmdResumeDownload,

                        iTransactionId,

                        KErrNone );

                break;

                }

            case ( EPbCmdCancelPd ):

                {

                iMStreamControl->Stop();

                iMStreamControl->Close();

                iMAudioProgDLSource->CancelDownload();

                iOngoingCmdCancelDownload = ETrue;

                iObs->HandlePluginEvent(

                        MMPXPlaybackPluginObserver::EPDownloadCmdCancelDownload,

                        iTransactionId,

                        KErrNone);

                break;

                }

            default:

                break;

            }

        }

    }

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

// Sets a property of the plugin

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

//

void CMPXProgressDownloadSB::SetL(

    TMPXPlaybackProperty aProperty,

    TInt aValue)

    {

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

    TBool isSupported=ETrue;

    switch(aProperty)

        {

        case EPbPropertyVolume:

            {

            SetVolume(aValue);

            }

            break;

        case EPbPropertyVolumeRamp:

            {

            TInt curVol = 0;

            MVolumeControl::TVolumeRampMode aMode = MVolumeControl::EIMMEDIATE;

            TUint64 duration = aValue;

            TInt err = iMVolumeControl->GetVolume(curVol);

            if(iMVolumeControl)

                {

                iMVolumeControl->SetVolumeRamp(0, curVol, duration, aMode);

                iMVolumeControl->Apply();

                }

            }

            break;

        case EPbPropertyMute:

            SetMute( aValue );

            break;

        case EPbPropertyBalance:

            break;

        default:

            isSupported=EFalse;

        }

    if (!isSupported)

        {

        User::Leave(KErrNotSupported);

        }

    iObs->HandlePluginEvent(MMPXPlaybackPluginObserver::EPSetComplete,

                             aProperty, KErrNone);

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

    }

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

// Gets a property of the plugin (async)

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

//

void CMPXProgressDownloadSB::PropertyL(TMPXPlaybackProperty aProperty) const

    {

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

    TBool isSupported=ETrue;

    TInt value=KErrNotFound;

    TInt err(KErrNone);

    switch(aProperty)

        {

        case EPbPropertyVolume:

            value = iVolumeWatcher->CurrentValueL();

            break;

        case EPbPropertyMaxVolume:

            iMVolumeControl->GetMaxVolume(value);

            break;

        case EPbPropertyMute:

            value = iMuteWatcher->CurrentValueL();

            break;

        case EPbPropertyBalance:

            //err = iPdPlayer->GetBalance(value);

            //value=Balance(value);

            break;

        case EPbPropertyDuration: