/*

* 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:  Implementation of Common Playback view

*

*/

// INCLUDE FILES

#include <aknViewAppUi.h>

#include <eikmenub.h>

#include <featmgr.h>

#include <StringLoader.h>

#include <eikapp.h>

#include <AknUtils.h>

#include <akntitle.h>

#include <aknnotewrappers.h>

#include <aknnavi.h>

#include <hlplch.h>

#include <bautils.h>

#include <centralrepository.h>

#include <avkon.hrh>

#include <avkon.rsg>

#include <bldvariant.hrh>

#include <caf/caferr.h>

#include <aknsoundsystem.h>

#include <AknDlgShut.h>

#include <ctsydomainpskeys.h>

#include <aknclearer.h>

#include <e32const.h>

#ifdef UPNP_INCLUDED

#include <upnpcopycommand.h>

#endif

#include <apgcli.h> // For FF_FMTX

#include <AknWaitDialog.h>

#include <aknSDData.h>

#include <AknMediatorFacade.h>

#include "mplayersecondarydisplayapi.h"

#include <data_caging_path_literals.hrh>

#include <layoutmetadata.cdl.h>

#include <mpxcommonplaybackview.rsg>

#include <mpxfmtx.rsg>

#include <mpxcommonui.rsg>

#include <mpxplaybackutility.h>

#include <mpxplaybackmessage.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxplaybackmessagedefs.h>

#include <mpxcollectionplaylist.h>

#include <mpxcollectionpath.h>

#include <mpxcollectionmessage.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 <mpxviewplugin.h>

#include <mpxviewpluginmanager.h>

#include <mpxmusicplayerviewplugin.hrh>

#include <mpxsubscription.h>

#include <mpxuser.h>

#include <mpxpskeywatcher.h>

#include <mpxcenrepwatcher.h>

#include <hwrmfmtx.h> // TFmTxState

#include <AiwServiceHandler.h>

#include <mediarecognizer.h>

#ifdef BACKSTEPPING_INCLUDED

#include <mpxbacksteppingutility.h>

#endif // BACKSTEPPING_INCLUDED

#include <UsbWatcherInternalPSKeys.h>

#include <usbpersonalityids.h>

#include "mpxconstants.h"

#include <mpxappui.hrh>

#include "mpxcommonplaybackview.hrh"

#include "mpxcommonplaybackviewimp.h"

#include "mpxcommonplaybackviewcontainer.h"

#include "mpxcommonplaybackviewlayout.h"

#include "mpxalbumartutil.h"

#include "mpxcommonuihelper.h"

#include <mpxinternalcrkeys.h>

#include <mpxtlshelper.h>

#include "mpxlog.h"

#include <akntoolbar.h>

#include <aknbutton.h>

#include "mpxviewprivatepskeys.h"

#include <gfxtranseffect/gfxtranseffect.h>

#include <akntranseffect.h>

// CONSTANTS

const TInt KMPXOneSecInMilliSecs( 1000 );

const TUid KMPXEqualizerViewImplementationId = { 0x101FFC77 };

const TInt KMPXPostponeForHandleDelayedError( 1000000 ); // 1S

const TInt KMPXPlaybackViewWindowBackground = -1;

const TInt KMPXDelayForTNRequest( 3000000 ); // 3S

// for freqency display in the format of "XXX.XX"

const TInt KMPXFMFreqWidth        = 6;

const TInt KMPXFMFreqDecimalPlace = 2;

const TInt KMPXOneMhzInOneKhz     = 1000;

const TUid KFmTxAppUid            = { 0x10282BEF };

#ifdef BACKSTEPPING_INCLUDED

const TInt KMaxIntLen( 10 );

_LIT8( KMVPrefix, "MVviewID:" );

const TInt KMVPrefixLen( 9 );

#endif // BACKSTEPPING_INCLUDED

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

// NOTE: All the FM Tx related values below originated from the files:

//       - HWRMFmTx.h

//       - HWRMFmTxDomainCRKeys.h

//       - HWRMFmTxDomainPSKeys.h

//

//       These values should be kept in sync with the original copies.  The

//       intention of keeping a copy here is to de-couple the MPX Music Player

//       from the Hardware Resource Manager who is the owner of the keys, as

//       FM Tx is not yet available for the platform.  Eventually, this should

//       be removed as FM Tx becomes part of the platform.

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

//

const TUid KCRUidFmTxCenRes = { 0x20008EA6 }; // FM TX Repository ID

const TUid KPSUidHWRMFmTx   = { 0x101F7A02 }; // FM TX category ID

// FM Tx frequency (kHz) key ID of the FM TX CenRep

const TUint32 KFmTxCenResKeyFrequency = 0x00000001;

// FM Transmitter status key ID of the FM TX property.

// Note: This data is interpreted as TFmTxState below

const TUint32 KHWRMFmTxStatus  = 0x00000001;

_LIT( KMPXCommonPlaybackRscPath, "mpxcommonplaybackview.rsc" );

_LIT( KMPXFMTXRscPath, "mpxfmtx.rsc" );

#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 ========

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

// Symbian 2nd phase constructor can leave.

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

//

EXPORT_C void CMPXCommonPlaybackViewImp::ConstructL()

    {

    MPX_FUNC( "CMPXCommonPlaybackViewImp::ConstructL" );

    CCoeEnv* coeEnv = iEikonEnv;

    TParse parse;

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

    TFileName resourceFile( parse.FullName() );

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

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

    iResourceOffset = coeEnv->AddResourceFileL( resourceFile );

    iTvOutConfig =   CTvOutConfig::NewL() ;

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

		}

    // Monitor for view activation

    AppUi()->AddViewActivationObserverL( this );

    // Get the playback utility instance from engine.

    iPlaybackUtility = MMPXPlaybackUtility::UtilityL( KPbModeDefault );

    iPlaybackUtility->AddObserverL( *this );

    iMPXUtility = CMPXAlbumArtUtil::NewL();

    iEmbedded = iEikonEnv->StartedAsServerApp();

    // Get an instance of view utility

    iViewUtility = MMPXViewUtility::UtilityL();

    iViewUtility->AddObserverL( this );

    TInt flags( 0 );

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

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

    CleanupStack::PopAndDestroy( repository );

    repository = NULL;

    iChangeRTForAllProfiles =

        static_cast<TBool>( flags & KMPXChangeRTForAll );

    iLayout = new (ELeave) CMPXCommonPlaybackViewLayout();

    iCollectionUtility = MMPXCollectionUtility::NewL( this );

#ifdef __USE_MESSAGE_SUBSCRIPTION

    // Subscribe to only a few messages from collection utility

    CMPXSubscription* subscription( CMPXSubscription::NewL() );

    CleanupStack::PushL( subscription );

    CMPXSubscriptionItem* subItem1( CMPXSubscriptionItem::NewL() );

    CleanupStack::PushL( subItem1 );

    subItem1->SetTObjectValueL( KMPXMessageGeneralId, KMPXMessageGeneral );

    subItem1->SetTObjectValueL( KMPXMessageGeneralEvent, TMPXCollectionMessage::EBroadcastEvent );

    subItem1->SetTObjectValueL( KMPXMessageGeneralType, EMcMsgDiskRemoved );

    subscription->AddItemL( *subItem1 );

    CMPXSubscriptionItem* subItem2( CMPXSubscriptionItem::CopyL( *subItem1 ));

    CleanupStack::PushL( subItem2 );

    subItem2->SetTObjectValueL( KMPXMessageGeneralType, EMcMsgUSBMassStorageStart );

    subscription->AddItemL( *subItem2 );

    CMPXSubscriptionItem* subItem3( CMPXSubscriptionItem::CopyL( *subItem1 ));

    CleanupStack::PushL( subItem3 );

    subItem3->SetTObjectValueL( KMPXMessageGeneralType, EMcMsgUSBMTPStart );

    subscription->AddItemL( *subItem3 );

    CMPXSubscriptionItem* subItem4( CMPXSubscriptionItem::CopyL( *subItem1 ));

    CleanupStack::PushL( subItem4 );

    subItem4->SetTObjectValueL( KMPXMessageGeneralType, EMcMsgFormatStart );

    subscription->AddItemL( *subItem4 );

    CMPXSubscriptionItem* subItem5( CMPXSubscriptionItem::CopyL( *subItem1 ));

    CleanupStack::PushL( subItem5 );

    subItem5->SetTObjectValueL( KMPXMessageGeneralType, EMcMsgUSBMassStorageEnd );

    subscription->AddItemL( *subItem5 );

    CMPXSubscriptionItem* subItem6( CMPXSubscriptionItem::CopyL( *subItem1 ));

    CleanupStack::PushL( subItem6 );

    subItem6->SetTObjectValueL( KMPXMessageGeneralType, EMcMsgUSBMTPEnd );

    subscription->AddItemL( *subItem6 );

    CMPXSubscriptionItem* subItem7( CMPXSubscriptionItem::CopyL( *subItem1 ));

    CleanupStack::PushL( subItem7 );

    subItem7->SetTObjectValueL( KMPXMessageGeneralType, EMcMsgFormatEnd );

    subscription->AddItemL( *subItem7 );

    CMPXSubscriptionItem* subItem8( CMPXSubscriptionItem::NewL() );

    CleanupStack::PushL( subItem8 );

    subItem8->SetTObjectValueL( KMPXMessageGeneralId, KMPXMessageGeneral );

    subItem8->SetTObjectValueL( KMPXMessageGeneralEvent, TMPXCollectionMessage::EPathChanged );

    subItem8->SetTObjectValueL( KMPXMessageGeneralType, EMcPathChangedByOpen );

    subItem8->SetTObjectValueL( KMPXMessageGeneralData, EMcItemOpened );

    subscription->AddItemL( *subItem8 );

    iCollectionUtility->Collection().AddSubscriptionL( *subscription );

    CleanupStack::PopAndDestroy( subItem8 );

    CleanupStack::PopAndDestroy( subItem7 );

    CleanupStack::PopAndDestroy( subItem6 );

    CleanupStack::PopAndDestroy( subItem5 );

    CleanupStack::PopAndDestroy( subItem4 );

    CleanupStack::PopAndDestroy( subItem3 );

    CleanupStack::PopAndDestroy( subItem2 );

    CleanupStack::PopAndDestroy( subItem1 );

    CleanupStack::PopAndDestroy( subscription );

#endif

    iCollectionUiHelper = CMPXCollectionHelperFactory::NewCollectionUiHelperL();

    iCommonUiHelper = CMPXCommonUiHelper::NewL( iCollectionUtility );

    // initialize FeatureManager

    FeatureManager::InitializeLibL();

    if ( FeatureManager::FeatureSupported( KFeatureIdFmtx ) )

        {

        // Since support of FM Tx remains the same within the lifetime of this

        // view, it is safe to determine whether to create the associated

        // PS & CR watcher here.

        // create the PS Key watcher to receive notification when FM

        // transmission status changes

        iPSKeyWatcher =

            CMPXPSKeyWatcher::NewL( KPSUidHWRMFmTx, KHWRMFmTxStatus, this );

        // create the Central Repository watcher to receive notification when

        // the value of the FM Frequency CR key is changed.

        iCRWatcher = CMPXCenRepWatcher::NewL(

            KCRUidFmTxCenRes,

            KFmTxCenResKeyFrequency,

            this );

        }

    iStartPlaybackIndex = KErrNotFound;

    iLastSkipDirection = 1;

    iSkipBtnPressed = EFalse;

    // Set to EFalse to avoid handling

    // errors if the view has not been activated

    // before.

    iLastPBViewActivated = EFalse;

    iDatabaseNotReady = EFalse;

    iIgnoredByUsbEvent = EFalse;

#ifdef _DEBUG

    iExitOptionHidden = EFalse;

#else // _DEBUG

    iExitOptionHidden = iCommonUiHelper->ExitOptionHiddenL() && !iEmbedded;

#endif // _DEBUG

    // Support for Camese Super Distribution

#ifdef __CAMESE_SUPERDISTRIBUTION_SUPPORT

    iCameseSuperDistSupport = ETrue;

#endif

    iMediaRecognizer = CMediaRecognizer::NewL();

    if ( iServiceHandler == NULL)

        {

        iServiceHandler = CAiwServiceHandler::NewL();

        MPX_DEBUG1("CMPXCollectionViewImp::ConstructL() Attaching 'Assign as' menu service...");

        MPX_TRAP( iErrorAttachAssignMenu, iServiceHandler->AttachMenuL( R_MPX_USE_AS_CASCADE,

                                                   R_MPX_AIW_ASSIGN_INTEREST ) );

        }

#ifdef BACKSTEPPING_INCLUDED

    // Initialize the Back Stepping Service Utility with the MPX Music Player

    iBackSteppingUtility = MMPXBackSteppingUtility::UtilityL();

    iBackSteppingUtility->InitializeL(

        TUid::Uid( KMusicPlayerAppUidConstant ) );

#endif // BACKSTEPPING_INCLUDED

#ifdef UPNP_INCLUDED

    if (!iUpnpCopyCommand )

        {

   	    MPX_TRAPD ( error, iUpnpCopyCommand = CUpnpCopyCommand::NewL() );

		    if ( error == KErrNone )

            {

            iUpnpFrameworkSupport = ETrue;

            }

        else

            {

            iUpnpFrameworkSupport = EFalse;

			iUpnpCopyCommand = NULL;

            }

        }

#endif

    iIsffButtonPressed = EFalse;

    iDelayedErrorTimer = CPeriodic::NewL( CActive::EPriorityStandard );

    iFmTxActivity = EFmTxStateUnknown;

    iTNRequestTimer = CPeriodic::NewL( CActive::EPriorityStandard );

    }

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

// Destructor

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

//

EXPORT_C CMPXCommonPlaybackViewImp::~CMPXCommonPlaybackViewImp()

    {

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

    AppUi()->RemoveViewActivationObserver( this );

    delete iMPXUtility;

    delete iMedia;

    delete iIdle;

    if ( iServiceHandler )

        {

        iServiceHandler->DetachMenu( R_MPX_USE_AS_CASCADE,

                                 R_MPX_AIW_ASSIGN_INTEREST );

        delete iServiceHandler;

        delete iMediaRecognizer;

        }

    delete iDelayedExit;

    if ( iPSKeyWatcher )

        {

        delete iPSKeyWatcher;

        }

    if ( iCRWatcher )

        {

        delete iCRWatcher;

        }

    if ( iPlaybackUtility )

        {

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

        iPlaybackUtility->Close();

        }

    if ( iViewUtility )

        {

        iViewUtility->RemoveObserver( this );

        iViewUtility->Close();

        }

    if ( iResourceOffset )

        {

        iEikonEnv->DeleteResourceFile( iResourceOffset );

        }

   	if ( iFMTXResourceOffset )

       	{

       	iEikonEnv->DeleteResourceFile( iFMTXResourceOffset );

       	}

#ifdef BACKSTEPPING_INCLUDED

    if( iBackSteppingUtility )

        {

        iBackSteppingUtility->Close();

        }

#endif // BACKSTEPPING_INCLUDED

    if ( iContainer )

        {

        AppUi()->RemoveFromStack( iContainer );

        delete iContainer;

        }

    delete iLayout;

    if ( iUpnpFrameworkSupport )

        {

        iPlayersList.Close();

        delete iSubPlayerName;

#ifdef UPNP_INCLUDED

        if (iUpnpCopyCommand)

            {

            delete iUpnpCopyCommand;

            }

#endif

        }

    delete iWaitNote;

    if ( iCollectionUtility )

        {

        iCollectionUtility->Close();

        }

    if ( iCollectionUiHelper )

        {

        iCollectionUiHelper->Close();

        }

    delete iCommonUiHelper;

    delete iUserPlaylists;

    if ( iKeySoundDisabled )

        {

        iAvkonViewAppUi->KeySounds()->PopContext();

        }

    // free up the FeatureManager

    FeatureManager::UnInitializeLib();

    if(iDelayedErrorTimer)

    	{

    	iDelayedErrorTimer->Cancel();

    	delete iDelayedErrorTimer;

    	}

    delete iOldUri;

    if ( iTNRequestTimer )

        {

        iTNRequestTimer->Cancel();

        delete iTNRequestTimer;

        }

	if(iTvOutConfig)

        {

        delete iTvOutConfig;

        }	

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

    }

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

// Updates playback view.

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

//

EXPORT_C void CMPXCommonPlaybackViewImp::UpdateViewL()

    {

    MPX_FUNC_EX( "CMPXCommonPlaybackViewImp::UpdateViewL" );

    if ( iContainer && !iSwitchingView )

        {

        UpdatePlaybackStateL( iPlaybackState );

        UpdateTrackInfoL( iMedia );

        UpdateTrackPlaybackPositionL( iPosition, iDuration );

        UpdateTrackPosInPlaylistL();

        UpdateAlbumArtL( iMedia );

        UpdateDownloadStateLabelL();

        UpdateFMTransmitterInfoL( ETrue );

        // Retrieve current repeat & random modes

        iPlaybackUtility->PropertyL( *this, EPbPropertyRandomMode );

        iPlaybackUtility->PropertyL( *this, EPbPropertyRepeatMode );

        }

    }

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

// Updates track info field.

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

//

EXPORT_C void CMPXCommonPlaybackViewImp::UpdateTrackInfoL(

    const CMPXMedia* aMedia )

    {

    MPX_FUNC_EX( "CMPXCommonPlaybackViewImp::UpdateTrackInfo" );

    if ( iContainer && !iSwitchingView )

        {

        if ( aMedia )

            {

            if ( aMedia->IsSupported( KMPXMediaGeneralTitle ) )

                {

                iContainer->UpdateLabelL(

                    ETextTrack,

                    aMedia->ValueText( KMPXMediaGeneralTitle ) );

                }