/*

* Copyright (c) 2008 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:  Implementation of CMPXVideoDownloadMgrInterface class.

*

*/

// Version : %version: 21 %

#include <MMFROPCustomCommandConstants.h>

#include <mmf/common/mmfcontrollerframework.h>

#include <mpxplaybackpluginobserver.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxcommandgeneraldefs.h>

#include <pathinfo.h>

#include <f32file.h>

#ifdef RD_MULTIPLE_DRIVE

#include <driveinfo.h>

#endif  //RD_MULTIPLE_DRIVE

#include "mpxvideoplaybackcontroller.h"

#include "mpxvideodlmgrif.h"

#include "mpxvideodrmhelper.h"

#include <mpxvideoplaybackdefs.h>

#include "mpxvideo_debug.h"

CMPXVideoDlMgrIf*

CMPXVideoDlMgrIf::NewL( CMPXVideoPlaybackController* aController )

{

    MPX_ENTER_EXIT(_L("CMPXVideoDlMgrIf::NewL()"));

    CMPXVideoDlMgrIf* self = new (ELeave) CMPXVideoDlMgrIf();

    CleanupStack::PushL( self );

    self->ConstructL( aController );

    CleanupStack::Pop();

    return self;

}

void CMPXVideoDlMgrIf::ConstructL( CMPXVideoPlaybackController* aController )

{

    iController = aController;

    iUpdateDownload = CIdle::NewL( CActive::EPriorityLow );

}

CMPXVideoDlMgrIf::CMPXVideoDlMgrIf()

    : iDlId(KErrNotFound)

{

}

CMPXVideoDlMgrIf::~CMPXVideoDlMgrIf()

{

    MPX_ENTER_EXIT(_L("CMPXVideoDlMgrIf::~CMPXVideoDlMgrIf()"));

    //

    //  Check if we need to move the clip or remove PDL flag from download

    //

    HandleClose();

    //

    //  Close the connection to the Download Manager

    //  if one has been established

    //

    if ( iDlMgrConnected )

    {

        iDlMgr.Close();

        iDlMgrConnected = EFalse;

    }

    if ( iUpdateDownload->IsActive() )

    {

        iUpdateDownload->Cancel();

    }

    delete iUpdateDownload;

    if ( iClipName )

    {

        delete iClipName;

        iClipName = NULL;

    }

}

void CMPXVideoDlMgrIf::ConnectToDownloadL( CMPXCommand& aCmd )

{

    MPX_ENTER_EXIT(_L("CMPXVideoDlMgrIf::ConnectToDownloadL()"));

    //

    //  Retrieve the download id from the message

    //

    TInt downloadId = *aCmd.Value<TInt>( KMPXCommandPlaybackPDTransactionID );

    TPtrC fileName( aCmd.ValueText( KMPXMediaVideoPlaybackFileName ) );

    iMovePdlFile = *aCmd.Value<TInt>( KMPXMediaVideoMovePdlFile );

    MPX_DEBUG(_L("CMPXVideoDlMgrIf::ConnectToDownloadL(%S, %d)"), &fileName, downloadId );

    if ( iClipName )

    {

        delete iClipName;

        iClipName = NULL;

    }

    iClipName = fileName.AllocL();

    //

    //  A new download id has been sent.  Reset member variables

    //

    iMoveNeeded    = EFalse;

    iCurrentDl     = NULL;

    iDlId          = downloadId;

    iPlayerOpened  = EFalse;

    iDlTotalSize   = 0;

    iDownloadProgress = 0;

    iCodDownload   = EFalse;

    if ( iDlMgrConnected )

    {

        iDlMgr.Close();

        iDlMgrConnected = EFalse;

    }

    if ( iDlId != KErrNotFound )

    {

        const TUid KUidLWPlayer = { 0x102824CD };

        //

        //  Connect to the Download Manager

        //

        iDlMgr.ConnectL( KUidLWPlayer, *this, EFalse );

        iDlMgrConnected = ETrue;

        //

        //  Attach to the download id

        //

        RHttpDownload& newDownload = iDlMgr.AttachToDownloadL( iDlId );

        //

        //  Update the members with the current download info

        //

        iCurrentDl = &newDownload;

        //

        //  Set the progressive download attribute on the download

        //

        iCurrentDl->SetBoolAttribute( EDlAttrProgressive, ETrue );

        iCurrentDl->SetBoolAttribute( EDlAttrSilent, EFalse );

        //a temp hack until dl manager has a fix for this

        TInt32 activeDownload( 0 );

        iCurrentDl->GetIntAttribute( EDlAttrActiveDownload, activeDownload );

        iCurrentDl->SetIntAttribute( EDlAttrActivePlayedDownload, activeDownload );

        //

        //  Set the Local File attribute

        //

        iCurrentDl->SetStringAttribute( EDlAttrLocalFileName, iClipName->Des() );

        TInt32 dlState;

        //

        //  Get the state, downloaded and total size of the download and save it

        //

        iCurrentDl->GetIntAttribute( EDlAttrLength, iDlTotalSize );

        iCurrentDl->GetIntAttribute( EDlAttrDownloadedSize, iDownloadProgress );

        iCurrentDl->GetIntAttribute( EDlAttrState, dlState );

        MPX_DEBUG(_L("   dlSize = %d, currentSize = %d, state = %d"),

            iDlTotalSize, iDownloadProgress, dlState );

        ConvertDMgrStatetoMpxState( dlState );

        if ( iDownloadState == EPbDlStateDownloadCompleted )

        {

            HandleDownloadComplete();

        }

        MPX_DEBUG(_L("CMPXVideoDlMgrIf::ConnectToDownloadL() Download State = %d Total Size=%d"),

            iDownloadState, iDlTotalSize);

    }

}

void

CMPXVideoDlMgrIf::HandleDMgrEventL( RHttpDownload& aDownload, THttpDownloadEvent aEvent )

{

    MPX_ENTER_EXIT(_L("CMPXVideoDlMgrIf::HandleDMgrEventL()"),

                   _L("iDownloadState = %d iProgressState = %d"),

                    aEvent.iDownloadState, aEvent.iProgressState );

    TMPXPlaybackPdDownloadState prevDownloadState = iDownloadState;

    if ( &aDownload == iCurrentDl )

    {

        switch ( aEvent.iDownloadState )

        {

            case EHttpDlInprogress:

            {

                iDownloadState = EPbDlStateDownloading;

                switch ( aEvent.iProgressState )

                {

                    case EHttpProgResponseBodyReceived:

                    {

                        if ( ! iUpdateDownload->IsActive() )

                        {

                            iUpdateDownload->Start(

                                    TCallBack( CMPXVideoDlMgrIf::UpdateDownloadProgress, this ) );

                        }

                        break;

                    }

                    case EHttpProgCodLoadEnd:

                    {

                        //

                        //  Set the member variable identifying this

                        //  as a COD download and handle the completion

                        //  of the download

                        //

                        iCodDownload = ETrue;

                        HandleDownloadComplete();

                        break;

                    }

                    case EHttpProgMovingContentFile:

                    {

                        //

                        //   Moving Started

                        //

                        MPX_DEBUG( _L("    Moving of file started"));

                        break;

                    }

                    case EHttpProgContentFileMoved:

                    case EHttpProgContentFileMovedAndDestFNChanged:

                    {

                        //

                        //  Move has completed, check error status

                        //

                        CheckForMoveError();

                        break;

                    }

                }

                break;

            }

            case EHttpDlPaused:

            {

                iDownloadState = EPbDlStateDownloadPaused;

                break;

            }

            case EHttpDlCompleted:

            {

                iDownloadState = EPbDlStateDownloadCompleted;

                switch ( aEvent.iProgressState )

                {

                    case EHttpProgNone:

                    {

                        //

                        //  Ignore this event since COD downloads send this

                        //  event after we have already moved the file.

                        //

                        if ( ! iCodDownload )

                        {

                            HandleDownloadComplete();

                        }

                        break;

                    }

                    case EHttpProgMovingContentFile:

                    {

                        //

                        //   Moving Started

                        //

                        MPX_DEBUG( _L("    Moving of file started"));

                        break;

                    }

                    case EHttpProgContentFileMoved:

                    case EHttpProgContentFileMovedAndDestFNChanged:

                    {

                        //

                        //  Move has completed, check error status

                        //

                        CheckForMoveError();

                        break;

                    }

                }

                break;

            }

            case EHttpDlFailed:

            case EHttpDlMediaRemoved:

            case EHttpDlDeleted:

            case EHttpDlDeleting:

            {

                iDownloadState = EPbDlStateDownloadCanceled;

                //

                //  Disconnect from the current download and Download Manager

                //

                iCurrentDl = NULL;

                iDlId = 0;

                break;

            }

            case EHttpDlMoved:

            case EHttpDlCreated:

            case EHttpContentTypeReceived:

            case EHttpDlMediaInserted:

            case EHttpDlPausable:

            case EHttpDlNonPausable:

            case EHttpDlAlreadyRunning:

            default:

                break;

        };

        if ( prevDownloadState != iDownloadState )

        {

            //

            //  Signal the view that the download state has changed

            //

            iController->iMPXPluginObs->HandlePluginEvent(

                MMPXPlaybackPluginObserver::EPDownloadStateChanged,

                iDownloadState,

                KErrNone );

        }

    }

    else

    {

        MPX_DEBUG(_L("CMPXVideoDlMgrIf::HandleDMgrEventL() Message for different Download"));

    }

}

void

CMPXVideoDlMgrIf::DoUpdateDownloadProgress()

{

    MPX_ENTER_EXIT(_L("CMPXVideoDlMgrIf::DoUpdateDownloadProgress()"));

    //

    //  Check if the current download is valid before updating

    //

    if ( iCurrentDl )

    {

        iCurrentDl->GetIntAttribute( EDlAttrDownloadedSize, iDownloadProgress );

        MPX_DEBUG(_L("   dlSize = %d, currentSize = %d"), iDlTotalSize, iDownloadProgress );

        //

        //  Update the size once the controller is initialized

        //

        if ( iController->iState->IsInitialized() )

        {

            iController->iMPXPluginObs->HandlePluginEvent(

                MMPXPlaybackPluginObserver::EPDownloadPositionChanged,

                iDownloadProgress,

                KErrNone );

            //

            //  Update the playback engine with the current downloaded size

            //  Helix needs this to handle reading past current file size

            //

            HandleCustomCommand( EMMFROPControllerSetDownloadSize, iDownloadProgress );

        }

    }

}

void

CMPXVideoDlMgrIf::DoHandleOpenComplete()

{

    MPX_ENTER_EXIT(_L("CMPXVideoDlMgrIf::DoHandleOpenComplete()"));

    if ( iCurrentDl )

    {

        //

        //  Set the player opened flag so messages can be sent to the

        //  video playback engine

        //

        iPlayerOpened = ETrue;

        //

        //  Do not enable progressive download on the playback engine

        //  if the download isn't active

        //

        if ( iDownloadState == EPbDlStateDownloading || iDownloadState == EPbDlStateDownloadPaused )

        {

            //

            //  Send the download id to Helix to trigger progressive

            //  download mode for the Helix engine

            //

            TInt error = HandleCustomCommand( EMMFROPControllerSetDownloadID, iDlId );

            if ( error == KErrNone )

            {

                iCurrentDl->GetIntAttribute( EDlAttrDownloadedSize, iDownloadProgress );

                //

                //  Update Helix with the current downloaded size

                //  Helix needs this to handle reading past current file size

                //

                error = HandleCustomCommand( EMMFROPControllerSetDownloadSize, iDownloadProgress );

            }

            //

            //  Update download size for DRM protected clips

            //

            MPX_TRAPD( updateError, UpdateDownloadSizeL() );

        }

    }

}

void

CMPXVideoDlMgrIf::CheckForMoveError()

{

    MPX_ENTER_EXIT(_L("CMPXVideoDlMgrIf::CheckForMoveError()"));

    TInt32 errorId = KErrNone;

    TInt32 globalErrorId = KErrNone;

    iCurrentDl->GetIntAttribute( EDlAttrErrorId, errorId );

    iCurrentDl->GetIntAttribute( EDlAttrGlobalErrorId, globalErrorId );

    MPX_DEBUG(_L("    Moving complete - error = %d global error = %d"), errorId, globalErrorId );

    //

    //  Move Complete

    //

    iMoveNeeded = EFalse;

    iDownloadState = EPbDlStateNotDownloading;

}

TInt CMPXVideoDlMgrIf::HandleCustomCommand( TUint32 aCommand, TUint32 aCmdValue )

{

    MPX_ENTER_EXIT(_L("CMPXVideoDlMgrIf::HandleCustomCommand()"),

                   _L(" aCommand = %d, aCmdValue = %d)"), aCommand, aCmdValue );

    TUint result = KErrNone;

    //

    //  Block custom commands for progressive download if the player has not been opened

    //

    if ( iPlayerOpened )

    {

        TPckgBuf<TUint> cmdValue( aCmdValue );

        const TMMFMessageDestinationPckg dest( KUidInterfaceMMFROPController );

        TPckgBuf<TMMFMessageDestination> message( dest );

        result = iController->iPlayer->CustomCommandSync( dest, aCommand, cmdValue, KNullDesC8 );

        MPX_DEBUG(_L("    Engine CustomCommand retCode = %d"), result);

    }

    return result;

}

void CMPXVideoDlMgrIf::HandleDownloadComplete()

{

    MPX_ENTER_EXIT(_L("CMPXVideoDlMgrIf::HandleDownloadComplete()"));

    iDownloadState = EPbDlStateDownloadCompleted;

    //

    //  Since the download is complete, download should be moved

    //

    if ( iMovePdlFile )

    {

        iMoveNeeded = ETrue;

    }

    else

    {

        //

        //  Disconnect from the current download since move is not required

        //

        iCurrentDl = NULL;

        iDlId = 0;

    }

    //

    //  If the update CIdle object is active, cancel it since the download

    //  is complete and we are updating the values.

    //

    if ( iUpdateDownload->IsActive() )

    {

        iUpdateDownload->Cancel();

    }

    //

    //  Notify the player and the UI view that the download is complete

    //

    HandleCustomCommand( EMMFROPControllerSetDownloadComplete, ETrue );

}

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

//  CMPXVideoDlMgrIf::UpdateDownloadProgress

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

//

TInt CMPXVideoDlMgrIf::UpdateDownloadProgress( TAny* aPtr )

{

    MPX_DEBUG(_L("CMPXVideoDlMgrIf::UpdateDownloadProgress()"));

    static_cast<CMPXVideoDlMgrIf*>(aPtr)->DoUpdateDownloadProgress();

    return KErrNone;

}

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

//  CMPXVideoDlMgrIf::GetPdlStatusL

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

//

void CMPXVideoDlMgrIf::GetPdlStatusL( CMPXCommand& aCmd )

{

    MPX_DEBUG(_L("CMPXVideoDlMgrIf::GetPdlStatusL()"));