/*

* 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:  Music Player upnp playback dialog implementation

*

*/

// INCLUDE FILES

#include <aknViewAppUi.h>

#include <StringLoader.h>

#include <akntitle.h>

#include <aknnotewrappers.h>

#include <aknnavide.h>

#include <aknnavilabel.h>

#include <coeutils.h>

#include <hlplch.h>

#include <bautils.h>

#include <centralrepository.h>

#include <bldvariant.hrh>

#include <caf/caferr.h>

#include <aknsoundsystem.h>

#include <apgcli.h>             // RApaLsSession

#include <ctsydomainpskeys.h>

#include <featmgr.h>

#include <hwrmfmtx.h> // TFmTxState, for FF_FMTX

#ifdef __SERIES60_31__

#include <upnpnetworkaccess.h>  // KCRUidUPnPApplication, KUPnPAppAccessPoint

#else

#include <upnpsettings.h>

#endif

#include <mpxcollectionmessage.h>

#include <mpxcollectionutility.h>

#include <mpxmediakeyhandler.h>

#include <data_caging_path_literals.hrh>

#include <layoutmetadata.cdl.h>

#include <mpxcommonplaybackview.rsg>

#include <mpxplaybackutility.h>

#include <mpxplaybackmessage.h>

#include <mpxmessagegeneraldefs.h>   // KMPXMessageGeneralId

#include <mpxplaybackmessagedefs.h>  // KMPXMessagePbMediaChanged, KMPXMessagePbMedia

#include <mpxcollectionplaylist.h>

#include <mpxcollectionpath.h>

#include <mpxviewutility.h>

#include <mpxmusicplayerviewplugin.hrh>

#include <mpxmedia.h>

#include <mpxmediaarray.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediamusicdefs.h>

#include <mpxmediadrmdefs.h>

#include <mpxmediacontainerdefs.h>

#include <mpxcollectionutility.h>

#include <mpxcollectionhelperfactory.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxconstants.h>

#include <mpxappui.hrh>

#include "mpxcommonplaybackview.hrh"

#include "mpxalbumartutil.h"

#include "mpxcommonuihelper.h"

#include <mpxinternalcrkeys.h>

#include <mpxtlshelper.h>

#include <mpxlog.h>

#include <mpxuser.h>

#include <akntoolbar.h> 

#include <aknbutton.h> 

#include "mpxupnpplaybackdialog.hrh"

#include "mpxupnpplaybackdialogcustomcontrol.h"

#include <mpxupnpplaybackview.rsg>

#include "mpxupnpplaybackdialogcustomcontrolcontainer.h"

#include "mpxupnpplaybackdialog.h"

#include "mpxupnpplaybackdialoglayout.h"

#include <mpxupnpplaybackdialog.rsg>

// CONSTANTS

const TInt KMPXOneSecInMilliSecs( 1000 );

_LIT( KMPXUPnPPlaybackDialogRscPath, "mpxUpnpPlaybackdialog.rsc" );

_LIT( KMPXCommonPlaybackRscPath, "mpxcommonplaybackview.rsc" );

_LIT( KMPXUpnpPlaybackRscPath, "mpxupnpplaybackview.rsc" );

_LIT( KMPXFMTXRscPath, "mpxfmtx.rsc" ); // For FF_FMTX

#ifdef RD_RA_SUPPORT_FOR_MUSIC_PLAYER

_LIT(KMPXPnRealAudioMimeType, "audio/x-pn-realaudio");

_LIT(KMPXRealAudioMimeType, "audio/x-realaudio");

_LIT(KMPXRnRealAudioMimeType, "audio/vnd.rn-realaudio");

#endif

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

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

// CMPXUPnPPlaybackDialog::NewL

// Two-phased constructor.

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

//

EXPORT_C CMPXUPnPPlaybackDialog* CMPXUPnPPlaybackDialog::NewL()

    {

    MPX_FUNC( "CMPXUPnPPlaybackDialog::NewL" );

    CMPXUPnPPlaybackDialog* self =

        new ( ELeave ) CMPXUPnPPlaybackDialog();

    CleanupStack::PushL( self );

    self->ConstructL( R_MPX_CUI_UPNP_PLAYBACK_DIALOG_MENUBAR );

    CleanupStack::Pop( self );  // this, it will be PushL-d by executeLD...

    return self;

    }

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

// CMPXUPnPPlaybackDialog::CMPXUPnPPlaybackDialog

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

// might leave.

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

//

CMPXUPnPPlaybackDialog::CMPXUPnPPlaybackDialog()

    {

    }

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

// CMPXUPnPPlaybackDialog::SetParamL

// parameter passed in from viewframework

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

//

EXPORT_C void CMPXUPnPPlaybackDialog::SetParamL( const TDesC* /*aParam*/ )

    {

    MPX_FUNC( "CMPXUPnPPlaybackDialog::SetParamL" );

    }

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

// CMPXUPnPPlaybackDialog::ConstructL

// (other items were commented in a header).

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

//

void CMPXUPnPPlaybackDialog::ConstructL( TInt aResource )

    {

    MPX_FUNC( "CMPXUPnPPlaybackDialog::ConstructL" );

    CCoeEnv* coeEnv = iEikonEnv;

    TParse parse;

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

    TFileName resourceFile( parse.FullName() );

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

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

    iResourceOffset = coeEnv->AddResourceFileL( resourceFile );

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

    TFileName playbackResourceFile( parse.FullName() );

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

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

    iCommonPlaybackResourceOffset = coeEnv->AddResourceFileL( playbackResourceFile );

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

    TFileName upnpResourceFile = parse.FullName();

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

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

    iUpnpResourceOffset = coeEnv->AddResourceFileL( upnpResourceFile );

    // CommonPlaybackViewLayout uses this rsc file so it needs to be loaded

	if ( FeatureManager::FeatureSupported( KFeatureIdFmtx ) )

		{

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

		TFileName fmtxResourceFile( parse.FullName() );

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

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

		iFMTXResourceOffset = coeEnv->AddResourceFileL( fmtxResourceFile );

		}

    // Get the playback utility instance from engine.

    iPlaybackUtility = MMPXPlaybackUtility::UtilityL( KPbModeDefault );

    iPlaybackUtility->AddObserverL( *this );

    iMPXUtility = CMPXAlbumArtUtil::NewL();

    iCommonUiHelper = CMPXCommonUiHelper::NewL();

    iEmbedded = iEikonEnv->StartedAsServerApp();

    // Get an instance of view utility

    iViewUtility = MMPXViewUtility::UtilityL();

    TInt flags( 0 );

    CRepository* repository( CRepository::NewL( KCRUidMPXMPFeatures ));

    User::LeaveIfError( repository->Get( KMPXMPLocalVariation, flags ));

    delete repository;

    repository = NULL;

    iChangeRTForAllProfiles =

        static_cast<TBool>( flags & KMPXChangeRTForAll );

    iCollectionUtility = MMPXCollectionUtility::NewL();

    iStartPlaybackIndex = KErrNotFound;

    iLastSkipDirection = 1;

    if ( !iMediaKeyHandler )

        {

        // Handle media key in appui

        iMediaKeyHandler = MMPXMediaKeyHandler::NewL(

            EDisplayVolumePopup | EDisplayMediaPopup,

            this );

        }

    CAknDialog::ConstructL( aResource );

    if ( AknLayoutUtils::PenEnabled())

        {

        CAknAppUi* appUi = static_cast<CAknAppUi*>( CCoeEnv::Static()->AppUi());

        iToolbar = appUi->CurrentFixedToolbar();

        if ( iToolbar )

            {

            iBtnPreviousItem = 

                CAknButton::NewL( R_MPX_PBV_TOUCH_TOOLBAR_PREVIOUS_ITEM_BTN );

            iBtnNextItem = 

                CAknButton::NewL( R_MPX_PBV_TOUCH_TOOLBAR_NEXT_ITEM_BTN );

            iBtnPlayPause = 

                CAknButton::NewL( R_MPX_PBV_TOUCH_TOOLBAR_PLAYPAUSE_BTN );

            iToolbar->AddItemL( iBtnPreviousItem, EAknCtButton, 

                    EMPXPbvCmdPreviousListItem, KAknButtonReportOnLongPress );

            iToolbar->AddItemL( iBtnPlayPause, EAknCtButton, 

                    EMPXPbvCmdPlayPause, 0 );

            iToolbar->AddItemL( iBtnNextItem, EAknCtButton, 

                    EMPXPbvCmdNextListItem, KAknButtonReportOnLongPress );

            iToolbar->SetToolbarVisibility( ETrue );

            iToolbar->SetToolbarObserver( this );

            }

        }

    }

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

// Destructor

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

//

EXPORT_C CMPXUPnPPlaybackDialog::~CMPXUPnPPlaybackDialog()

    {

    MPX_FUNC( "CMPXUPnPPlaybackDialog::~CMPXUPnPPlaybackDialog" );

    delete iMPXUtility;

    delete iMedia;

    delete iCommonUiHelper;

    if ( iPlaybackUtility )

        {

        TRAP_IGNORE( iPlaybackUtility->RemoveObserverL( *this ) );

        iPlaybackUtility->Close();

        }

    if ( iViewUtility )

        {

        iViewUtility->Close();

        }

    if ( iResourceOffset )

        {

        iEikonEnv->DeleteResourceFile( iResourceOffset );

        }

    if ( iCommonPlaybackResourceOffset )

        {

        iEikonEnv->DeleteResourceFile( iCommonPlaybackResourceOffset );

        }

    iPlayersList.Close();

    delete iSubPlayerName;

    if ( iUpnpResourceOffset )

        {

        iEikonEnv->DeleteResourceFile( iUpnpResourceOffset );

        }

	if ( iFMTXResourceOffset )

		{

		iEikonEnv->DeleteResourceFile( iFMTXResourceOffset );

		}

    if ( iCollectionUtility )

        {

        iCollectionUtility->Close();

        }

    if ( iKeySoundDisabled )

        {

        iAvkonAppUi->KeySounds()->PopContext();

        }

    delete iOrigTitle;

    delete iPlaybackDialogLayout;

    delete iMediaKeyHandler;

    if ( iDelayedEventExit )

        {

        iDelayedEventExit->Cancel();

        }

    delete iDelayedEventExit;

    }

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

// Updates playback view.

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

//

void CMPXUPnPPlaybackDialog::UpdateViewL()

    {

    MPX_FUNC( "CMPXUPnPPlaybackDialog::UpdateViewL" );

    if ( GetUPnPPlaybackDialogCustomControl() && !iSwitchingView )

        {

        UpdatePlaybackState( iPlaybackState );

        UpdateTrackInfoL( iMedia );

        UpdateTrackPlaybackPositionL( iPosition, iDuration );

        UpdateTrackPosInPlaylistL();

        UpdateAlbumArtL( iMedia );

        UpdateDownloadStateLabelL();

        // Retrieve current repeat & random modes

        iPlaybackUtility->PropertyL( *this, EPbPropertyRandomMode );

        iPlaybackUtility->PropertyL( *this, EPbPropertyRepeatMode );

        iPlaybackUtility->PropertyL( *this, EPbPropertyVolume);

        }

    }

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

// Updates track info field.

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

//

void CMPXUPnPPlaybackDialog::UpdateTrackInfoL(

    const CMPXMedia* aMedia )

    {

    MPX_FUNC( "CMPXUPnPPlaybackDialog::UpdateTrackInfo" );

    if ( GetUPnPPlaybackDialogCustomControl() && !iSwitchingView )

        {

        if ( aMedia )

            {

            if ( aMedia->IsSupported( KMPXMediaGeneralTitle ) )

                {

                GetUPnPPlaybackDialogCustomControl()->UpdateLabelL(

                    ETextTrack,

                    aMedia->ValueText( KMPXMediaGeneralTitle ) );

                }

            else if ( aMedia->IsSupported( KMPXMediaGeneralUri ) )

                {

                TParsePtrC filePath(

                    aMedia->ValueText( KMPXMediaGeneralUri ) );

                GetUPnPPlaybackDialogCustomControl()->UpdateLabelL(

                    ETextTrack, filePath.Name() );

                }

            else

                {

                GetUPnPPlaybackDialogCustomControl()->UpdateLabelL(

                    ETextTrack, KNullDesC );

                }

            if ( aMedia->IsSupported( KMPXMediaMusicArtist ) )

                {

                const TDesC& artist =

                    aMedia->ValueText( KMPXMediaMusicArtist );

                if ( artist != KNullDesC )

                    {

                    GetUPnPPlaybackDialogCustomControl()->UpdateLabelL(

                        ETextArtist,

                        artist );

                    }

                else

                    {

                    if ( !iSkipping )

                        {

                        // Display unknown artist as artist

                        HBufC* unknownArtistText =

                            StringLoader::LoadLC( R_MPX_PBV_UNKNOWN_ARTIST_LABEL );

                        GetUPnPPlaybackDialogCustomControl()->UpdateLabelL(

                            ETextArtist, *unknownArtistText );

                        CleanupStack::PopAndDestroy( unknownArtistText );

                        }

                    else

                        {

                        GetUPnPPlaybackDialogCustomControl()->UpdateLabelL(

                            ETextArtist, KNullDesC );

                        }

                    }

                }

            else

                {

                GetUPnPPlaybackDialogCustomControl()->UpdateLabelL(

                    ETextArtist, KNullDesC );

                }

#ifdef RD_RA_SUPPORT_FOR_MUSIC_PLAYER

            if ( aMedia->IsSupported( KMPXMediaGeneralMimeType ) )

                {

                // Get mime type

                const TDesC& mimeType = aMedia->ValueText(

                                                KMPXMediaGeneralMimeType );

                const TBool realAudioMode =

                    ( mimeType.Compare( KMPXPnRealAudioMimeType ) == 0 ) ||

                    ( mimeType.Compare( KMPXRealAudioMimeType ) == 0) ||

                    ( mimeType.Compare( KMPXRnRealAudioMimeType ) == 0 );

                MPX_DEBUG2("CMPXUPnPPlaybackDialog::UpdateTrackInfoL() mimeType: %S", &mimeType);

                // Set the real audio mode

                GetUPnPPlaybackDialogCustomControl()->SetRealAudioMode( realAudioMode );

                }

            else

                {

                GetUPnPPlaybackDialogCustomControl()->SetRealAudioMode( EFalse );

                }

#endif

            }

        else

            {

            // Display nothing if properties is NULL

            GetUPnPPlaybackDialogCustomControl()->UpdateLabelL(

                ETextTrack, KNullDesC );

            GetUPnPPlaybackDialogCustomControl()->UpdateLabelL(

                ETextArtist, KNullDesC );

            }

        }

    }

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

// Update current playback state.

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

//

void CMPXUPnPPlaybackDialog::UpdatePlaybackState(

    TMPXPlaybackState aPlaybackState )

    {

    MPX_FUNC( "CMPXUPnPPlaybackDialog::UpdatePlaybackState()" );

    MPX_DEBUG2("CMPXUPnPPlaybackDialog::UpdatePlaybackState(%d): Entering", aPlaybackState);

    if ( GetUPnPPlaybackDialogCustomControl() && !iSwitchingView )

        {

        TMPXPbvPlaybackMode mode( EInvalidMode );

        switch ( aPlaybackState )

            {

            case EPbStateNotInitialised:

                {

                mode = ENoTracksMode;

                break;

                }

            case EPbStateInitialising:

            case EPbStateDownloading:

                {

                mode = EInitialising;

                break;

                }

            case EPbStatePlaying:

                {

                mode = EPlayMode;

                break;

                }

            case EPbStatePaused:

                {

                mode = EPauseMode;

                break;

                }

            case EPbStateStopped:

                {

                mode = EStopMode;

                break;

                }

            default:

                {

                // Pass

                break;

                }

            }

        if ( EInvalidMode != mode )

            {

            iPlaybackState = aPlaybackState;

            GetUPnPPlaybackDialogCustomControl()->SetMode( mode );

            }

        GetUPnPPlaybackDialogCustomControl()->UpdateButtons( aPlaybackState );

        UpdateToolbar();

        }

    else

        {

        // If no container, just need to update state

        switch ( aPlaybackState )

            {

            case EPbStateNotInitialised:

            case EPbStateInitialising:

            case EPbStateDownloading:

            case EPbStatePlaying:

            case EPbStatePaused:

            case EPbStateStopped:

                {

                iPlaybackState = aPlaybackState;

                break;

                }

            default:

                {

                // Pass

                // Ignore other state changes such as skipping, etc.

                break;

                }

            }

        }

    }

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

// Updates track's playback position.

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

//

void CMPXUPnPPlaybackDialog::UpdateTrackPlaybackPositionL(

    TInt aPos,

    TInt aDuration )

    {

    MPX_FUNC( "CMPXUPnPPlaybackDialog::UpdateTrackPlaybackPosition" );

    if ( GetUPnPPlaybackDialogCustomControl() && !iSwitchingView )

        {

        if ( aPos > aDuration )