/*

* Copyright (c) 2007 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 Progressive Download Playback view

*

*/

// INCLUDE FILES

#include <aknViewAppUi.h>

#include <eikmenub.h>

#include <eikapp.h>

#include <AknUtils.h>

#include <bautils.h>

#include <featmgr.h>

#include <data_caging_path_literals.hrh>

#include <mpxplaybackmessage.h>

#include <mpxcommonplaybackview.rsg>

#include <mpxpdsbplaybackview.rsg>

#include <mpxcmn.h>

#include <mpxplaybackutility.h>

#include <mpxviewutility.h>

#include <StringLoader.h>

#include <AknQueryDialog.h>

#include <MProfileEngine.h>

#include <e32property.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxcommandgeneraldefs.h>

#include <apgwgnam.h>

#include <mpxuser.h>

#include <sacls.h>

#include "mpxcommonuihelper.h"

#include "mpxcommonplaybackview.hrh"

#include "mpxpdsbplaybackview.hrh"

#include "mpxpdsbplaybackviewimp.h"

#include "mpxpdsbplaybackviewcontainer.h"

#include "mpxpdsbplaybackviewlayout.h"

#include "mpxlog.h"

#include "mpxappui.hrh"

#include <akntoolbar.h>

#include <aknbutton.h>

// CONSTANTS

_LIT( KMPXPdSbPlaybackRscPath, "mpxpdsbplaybackview.rsc" );

#define KMPlayerBrowserUid    0x10008D39

#define KMPlayerBrowserUid2   0x1020724D

#define KProgressDownloadUid  0x10207BCD

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

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

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CMPXPdSbPlaybackViewImp::CMPXPdSbPlaybackViewImp()

    {

    // Do nothing

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CMPXPdSbPlaybackViewImp::ConstructL()

    {

    MPX_FUNC( "CMPXPdSbPlaybackViewImp::ConstructL" );

    CMPXCommonPlaybackViewImp::ConstructL();

    iPlaybackUtility->RemoveObserverL( *this );

    iPlaybackUtility->Close();

    iPlaybackUtility = MMPXPlaybackUtility::UtilityL( TUid::Uid(KProgressDownloadUid) );

    iPlaybackUtility->AddObserverL( *this );

    // Need to set a higher priority because download manager sets it's

    // own priority high, so we need to make sure we're at least the same

    iPlaybackUtility->SetPriority( CActive::EPriorityStandard + 2 );

    CCoeEnv* coeEnv = iEikonEnv;

    TParse parse;

    parse.Set( KMPXPdSbPlaybackRscPath, &KDC_APP_RESOURCE_DIR, NULL );

    TFileName resourceFile = parse.FullName();

    User::LeaveIfError( MPXUser::CompleteWithDllPath( resourceFile ) );

    BaflUtils::NearestLanguageFile( coeEnv->FsSession(), resourceFile );

    iPdResourceOffset = coeEnv->AddResourceFileL( resourceFile );

    BaseConstructL( R_MPX_PD_SB_PLAYBACK_VIEW );

    if(AknLayoutUtils::PenEnabled())

        {

        CAknView::ShowToolbarOnViewActivation(ETrue);

        if ( Toolbar() )

            {

            iToolbar = Toolbar();

            iToolbar->SetToolbarObserver( this );

            }

        }

    iDownloadState = EPbDlStateDownloading;     // Otherwise we will show "Download Stopped"

    }

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

// Two-phased constructor.

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

//

CMPXPdSbPlaybackViewImp* CMPXPdSbPlaybackViewImp::NewL()

    {

    CMPXPdSbPlaybackViewImp* self = CMPXPdSbPlaybackViewImp::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// Two-phased constructor.

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

//

CMPXPdSbPlaybackViewImp* CMPXPdSbPlaybackViewImp::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// Destructor

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

//

CMPXPdSbPlaybackViewImp::~CMPXPdSbPlaybackViewImp()

    {

    MPX_DEBUG1( "CMPXPdSbPlaybackViewImp::~CMPXPdSbPlaybackViewImp entering" );

    delete iPlaybackViewLayout;

    if ( iPdResourceOffset )

        {

        iEikonEnv->DeleteResourceFile( iPdResourceOffset );

        }

    MPX_DEBUG1( "CMPXPdSbPlaybackViewImp::~CMPXPdSbPlaybackViewImp exiting" );

    }

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

// Gets download information

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

//

void CMPXPdSbPlaybackViewImp::GetDownloadInformationL(

        TUint& aTransactionId,

        TMPXPlaybackPdDownloadState& aState,

        TInt& aDownloadedBytes,

        TInt& aTotalBytes )

    {

    MPX_DEBUG1("CMPXPdSbPlaybackViewImp::GetDownloadInformationL() entering");

    // Create the command to send to MPX

    CMPXCommand* cmd( CMPXCommand::NewL() );

    CleanupStack::PushL( cmd );

    cmd->SetTObjectValueL<TBool>( KMPXCommandGeneralDoSync, ETrue );

    cmd->SetTObjectValueL<TInt>( KMPXCommandGeneralId, KMPXCommandIdPlaybackPD );

    cmd->SetTObjectValueL<TMPXPlaybackPdCommand>( KMPXCommandPlaybackGeneralType, EPbCmdGetPdStatus );

    iPlaybackUtility->CommandL( *cmd );

    // Check that return values were provided

    ASSERT( cmd->IsSupported( KMPXCommandPlaybackPDTransactionID ) &&

            cmd->IsSupported( KMPXCommandPlaybackPDState ) &&

            cmd->IsSupported( KMPXCommandPlaybackPDDownloadedBytes ) &&

            cmd->IsSupported( KMPXCommandPlaybackPDTotalBytes ));

    // Copy the return values

    aTransactionId = cmd->ValueTObjectL<TUint>( KMPXCommandPlaybackPDTransactionID );

    aState = cmd->ValueTObjectL<TMPXPlaybackPdDownloadState>( KMPXCommandPlaybackPDState );

    aDownloadedBytes = cmd->ValueTObjectL<TInt>( KMPXCommandPlaybackPDDownloadedBytes );

    aTotalBytes = cmd->ValueTObjectL<TInt>( KMPXCommandPlaybackPDTotalBytes );

    CleanupStack::PopAndDestroy( cmd );

    MPX_DEBUG1("CMPXPdSbPlaybackViewImp::GetDownloadInformationL() exiting");

    }

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

// CMPXPdSbPlaybackViewImp::CheckSignalAvailableL

// This checks for Network available, and Network Strength > none.

// - Return ETrue if network available and network strength

// is Low or Medium or High, otherwise return EFalse.

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

//

TBool CMPXPdSbPlaybackViewImp::CheckSignalAvailableL( TUid& aCheck, TInt& aState )

    {

    TBool ret( ETrue );

    // Check the network is available.

    aCheck = KUidNetworkStatus;

    TInt err( RProperty::Get( KUidSystemCategory, KUidNetworkStatusValue, aState ));

    if ( err != KErrNone )

        {

        aState = ESANetworkUnAvailable;

        }

    if( aState != ESANetworkAvailable )

        {

        ret = EFalse;

        }

    // Check network coverage.

    aCheck = KUidNetworkStrength;

    err = RProperty::Get( KUidSystemCategory, KUidNetworkStrengthValue, aState );

    if ( err != KErrNone )

        {

        aState = ESANetworkStrengthUnknown;

        }

    if( aState != ESANetworkStrengthLow &&

        aState != ESANetworkStrengthMedium &&

        aState != ESANetworkStrengthHigh )

        {

        ret = EFalse;

        }

    //passed all tests, OK to send

    return ret;

    }

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

// Handle playback message.

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

//

void CMPXPdSbPlaybackViewImp::DoHandlePlaybackMessageL(

    const CMPXMessage& aMessage )

    {

    MPX_FUNC( "-->CMPXPdSbPlaybackViewImp::DoHandlePlaybackMessageL" );

    TMPXMessageId id( aMessage.ValueTObjectL<TMPXMessageId>( KMPXMessageGeneralId ) );

    if ( KMPXMessageGeneral == id )

        {

        TInt type( aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralType ) );

        TInt data( aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralData ) );

        MPX_DEBUG2( "CMPXPdPlaybackViewImp::DoHandlePlaybackMessageL type = %d", type );

        switch ( aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralEvent ) )

            {

            case TMPXPlaybackMessage::EDownloadPositionChanged:

                {

                if ( iContainer )

                    {

                    MPX_DEBUG2( "CMPXPdPlaybackViewImp::DoHandlePlaybackMessageL - EDownloadPositionChanged(%d)", data );

                    CMPXPdSbPlaybackViewContainer* container =

                        static_cast<CMPXPdSbPlaybackViewContainer*>(iContainer);

                    container->HandleDownloadPositionChanged( data, iTotalBytes );

                    }

                break;

                }

            case TMPXPlaybackMessage::EDownloadStateChanged:

                {

                TInt data( *aMessage.Value<TInt>( KMPXMessageGeneralData ) );

                MPX_DEBUG2( "CMPXPdSbPlaybackViewImp::DoHandlePlaybackMessageL - EDownloadStateChanged(%d)", data );

                iDownloadState = static_cast<TMPXPlaybackPdDownloadState>( data );

                if ( iDownloadState == EPbDlStateDownloading ||

                     iDownloadState == EPbDlStateDownloadCompleted )

                    {

                    RequestMediaL();

                    }

                if( iContainer && iDownloadState == EPbDlStateDownloadCompleted )

                    {

                    CMPXPdSbPlaybackViewContainer* container =

                        static_cast<CMPXPdSbPlaybackViewContainer*>(iContainer);

                    container->HandleDownloadPositionChanged( iTotalBytes, iTotalBytes );

                    }

                UpdateViewL();

                break;

                }

            case TMPXPlaybackMessage::EStateChanged:

                {

                MPX_DEBUG2( "CMPXPdSbPlaybackViewImp::DoHandlePlaybackMessageL - EStateChanged(%d)", type );

                UpdateToolbarL();

                UpdateMiddleSoftKeyDisplayL();

                TInt data( *aMessage.Value<TInt>( KMPXMessageGeneralData ) );

                TMPXPlaybackState state =

                    static_cast<TMPXPlaybackState>( type );

                DoHandleStateChangedL( state, data );

                if ( iDownloadState == EPbDlStateDownloadPaused && state == EPbStatePaused )

                    {

                    iCommonUiHelper->DisplayInfoNoteL( R_MPX_DOWNLOAD_PLAYED_ALL_CONTENT );

                    }

                break;

                }

            case TMPXPlaybackMessage::EDownloadStarted:

                {

                iTotalBytes = aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralData );

                MPX_DEBUG2( "CMPXPdSbPlaybackViewImp::DoHandlePlaybackMessageL - DownloadStarted, totalBytes = %d", iTotalBytes );

                break;

                }

            case TMPXPlaybackMessage::EDownloadUpdated:

                {

                iTotalBytes = aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralData );

                MPX_DEBUG2( "CMPXPdSbPlaybackViewImp::DoHandlePlaybackMessageL - DownloadUpdated, totalBytes = %d", iTotalBytes );

                break;

                }

            case TMPXPlaybackMessage::EMediaChanged:

                iPlaybackCompleted = ETrue;

                if ( !iForeground )

                    {

                    //TODO: Add something like AppUi()->HandleCommandL( EMPXCmdGoToNowPlaying ); but it should not bring to foreground

                    }

                break;

            case TMPXPlaybackMessage::EDownloadCmdCancelDownload:

                // stop playback

                // bring back previous now playing view

                AppUi()->HandleCommandL( EMPXCmdGoToNowPlaying );

                // Bring Browser to foreground.

                BringUpBrowserL();

                break;

            case TMPXPlaybackMessage::EDownloadFileMoved:

                {

                // set updated Uri from aMessage for iMedia

                iMedia->SetTextValueL( KMPXMediaGeneralUri, aMessage.ValueText( KMPXMediaGeneralUri ) );

                break;

                }

            default:

                {

                CMPXCommonPlaybackViewImp::DoHandlePlaybackMessageL( aMessage );

                break;

                }

            }

        }

    MPX_DEBUG1("<--CMPXPdSbPlaybackViewImp::DoHandlePlaybackMessageL()");

    }

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

// Handle playback state changed.

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

//

void CMPXPdSbPlaybackViewImp::DoHandleStateChangedL(

    TMPXPlaybackState aState,

    TInt aData )

    {

    MPX_DEBUG2( "CMPXPdSbPlaybackViewImp::DoHandleStateChangedL(%d)", aState );

    switch ( aState )

        {

        case EPbStateInitialising:

            {

            UpdatePlaybackStateL( aState );

            UpdateDownloadStateLabelL();

            RequestMediaL();

            break;

            }

        case EPbStatePlaying:

            RequestMediaL();

            CMPXCommonPlaybackViewImp::DoHandleStateChangedL( aState, aData );

            break;

        case EPbStateStopped:

        case EPbStatePaused:

            if ( iExiting )

                {

                AppUi()->RunAppShutter();

                }

        default:

            {

            CMPXCommonPlaybackViewImp::DoHandleStateChangedL( aState, aData );

            break;

            }

        }

    MPX_DEBUG1("CMPXPdSbPlaybackViewImp::DoHandleStateChangedL()");

    }

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

// Updates download state label.

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

//

void CMPXPdSbPlaybackViewImp::UpdateDownloadStateLabelL()

    {

    MPX_DEBUG1("CMPXPdSbPlaybackViewImp::UpdateDownloadStateLabelL() entering");

    if ( iContainer && !iSwitchingView )

        {

        TInt resId = KErrNotFound;

        switch ( iDownloadState )

            {

            case EPbDlStateBuffering:

                {

                MPX_DEBUG1("CMPXPdSbPlaybackViewImp::UpdateDownloadStateLabelL() - Buffering");

                resId = R_MPX_DOWNLOAD_STATUS_BUFFERING;

                break;

                }

            case EPbDlStateDownloadPaused:

                {

                // If offline mode, this case will be entered.

                resId = R_MPX_DOWNLOAD_STATUS_PAUSED;

                TBool offLine( EFalse );

                // Check profile, display "Download Stopped" if

                // Offline enabled.

                MProfileEngine* profileEngine( CreateProfileEngineL() );

                if ( profileEngine->ActiveProfileId() == EProfileOffLineId )

                    {

                    MPX_DEBUG1("CMPXPdSbPlaybackViewImp::UpdateDownloadStateLabelL() -- OffLine ");

                    offLine = ETrue;

                    resId = R_MPX_DOWNLOAD_STATUS_INTERRUPTED;

                    }

                profileEngine->Release();

                if ( !offLine )

                    {

                    // Check network coverage, display "Download Stopped" if

                    // No coverage.

                    TUid uid;

                    TInt res( 0 );

                    TBool signalAvailable( CheckSignalAvailableL( uid, res ));

                    if ( !signalAvailable )

                        {

                        MPX_DEBUG1("CMPXPdSbPlaybackViewImp::UpdateDownloadStateLabelL() -- No Signal ");

                        resId = R_MPX_DOWNLOAD_STATUS_INTERRUPTED;

                        }

                    }

                break;

                }

            case EPbDlStateDownloadError:

            case EPbDlStateDownloadCanceled:

            case EPbDlStateNotDownloading:

                {

                MPX_DEBUG1("CMPXPdSbPlaybackViewImp::UpdateDownloadStateLabelL() - Download Canceled");

                resId = R_MPX_DOWNLOAD_STATUS_INTERRUPTED;

                break;

                }

            case EPbDlStateDownloadCompleted:

                {

                MPX_DEBUG1("CMPXPdSbPlaybackViewImp::UpdateDownloadStateLabelL() - Download Completed");

                resId = R_MPX_DOWNLOAD_STATUS_COMPLETED;

                break;

                }

            case EPbDlStateDownloading:

            default:

                {

                MPX_DEBUG2(" default state: %d", iDownloadState );

                // Do nothing

                break;

                }

            }

/*

        // Display Album art in progressive download

        if( iActualAlbumArtBitmap )

            {

            MPX_DEBUG1("CMPlayerPlaybackContainer::UpdateDownloadStateLabelL() - Draw ActualAlbumArt");

            iAlbumArtBitmap = iActualAlbumArtBitmap;

            DrawNow();

            }

        else

            {

            MPX_DEBUG1("CMPlayerPlaybackContainer::UpdateDownloadStateLabelL() - Draw DefaultAlbumArt");

            // Display default Album Art

            iAlbumArtBitmap = iDefaultAlbumArtBitmap;

            DrawNow();

            }

*/

        if (resId != KErrNotFound)

            {

            // Display download status text

            HBufC* statusText = StringLoader::LoadLC( resId );

            iContainer->UpdateLabelL( ETextDownloadState, *statusText );

            CleanupStack::PopAndDestroy( statusText );

            }

        else

            {

            // Clear download status text

            iContainer->UpdateLabelL( ETextDownloadState, KNullDesC );

            }

        }

    MPX_DEBUG1("CMPXPdSbPlaybackViewImp::UpdateDownloadStateLabelL() exiting");

    }

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

// Displays error notes.

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

//

void CMPXPdSbPlaybackViewImp::HandleErrorL( TInt aError )

    {

    MPX_DEBUG2("CMPXPdSbPlaybackViewImp::HandleErrorL(%d): Entering", aError);

    if ( aError )

        {

        TUint transactionId(0);

        TMPXPlaybackPdDownloadState state( EPbDlStateNotDownloading );

        TInt downloadedBytes(0);

        TInt totalBytes(0);

        GetDownloadInformationL( transactionId,

                                 state,

                                 downloadedBytes,

                                 totalBytes );

        if ( EPbDlStateBuffering == state ||

             EPbDlStateDownloading == state ||

             EPbDlStateDownloadPaused == state )

            {

            CMPXCommand* cmd( CMPXCommand::NewL() );

            CleanupStack::PushL( cmd );

            cmd->SetTObjectValueL<TBool>( KMPXCommandGeneralDoSync, ETrue );

            cmd->SetTObjectValueL<TInt>( KMPXCommandGeneralId, KMPXCommandIdPlaybackPD );

            cmd->SetTObjectValueL<TMPXPlaybackPdCommand>(

                KMPXCommandPlaybackGeneralType,

                EPbCmdCancelPd );

            iPlaybackUtility->CommandL( *cmd );

            CleanupStack::PopAndDestroy( cmd );

            }

        iCommonUiHelper->HandleErrorL( aError );

        CMPXCommonPlaybackViewImp::HandleCommandL( EAknSoftkeyBack );

        }

    }

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

// From MEikMenuObserver

// Dynamically initialises a menu pane.

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