diff -r 14979e23cb5e -r 3de6c4cf6b67 mpxplugins/viewplugins/views/commonplaybackview/src/mpxcommonplaybackviewimp.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mpxplugins/viewplugins/views/commonplaybackview/src/mpxcommonplaybackviewimp.cpp Wed Sep 01 12:32:02 2010 +0100 @@ -0,0 +1,4107 @@ +/* +* 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +#include +#ifdef UPNP_INCLUDED +#include +#endif + +#include // For FF_FMTX +#include + +#include +#include +#include "mplayersecondarydisplayapi.h" + +#include +#include +#include + + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include // TFmTxState +#include +#include +#ifdef BACKSTEPPING_INCLUDED +#include +#endif // BACKSTEPPING_INCLUDED +#include +#include + +#include "mpxconstants.h" +#include +#include "mpxcommonplaybackview.hrh" +#include "mpxcommonplaybackviewimp.h" +#include "mpxcommonplaybackviewcontainer.h" +#include "mpxcommonplaybackviewlayout.h" +#include "mpxalbumartutil.h" +#include "mpxcommonuihelper.h" +#include +#include +#include "mpxlog.h" + +#include +#include +#include "mpxviewprivatepskeys.h" +#include +#include + +// CONSTANTS +const TInt KMPXOneSecInMilliSecs( 1000 ); +const TUid KMPXEqualizerViewImplementationId = { 0x101FFC77 }; +const TUid KMPXMetadataEditorDialogImplementationId = { 0x101FFC83 }; +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( 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 ) ); + } + else if ( aMedia->IsSupported( KMPXMediaGeneralUri ) ) + { + TParsePtrC filePath( + aMedia->ValueText( KMPXMediaGeneralUri ) ); + iContainer->UpdateLabelL( + ETextTrack, filePath.Name() ); + } + else + { + iContainer->UpdateLabelL( + ETextTrack, KNullDesC ); + } + + if ( aMedia->IsSupported( KMPXMediaMusicArtist ) ) + { + const TDesC& artist = + aMedia->ValueText( KMPXMediaMusicArtist ); + if ( artist != KNullDesC ) + { + iContainer->UpdateLabelL( + ETextArtist, + artist ); + } + else + { + // Display unknown artist as artist + HBufC* unknownArtistText = + StringLoader::LoadLC( R_MPX_PBV_UNKNOWN_ARTIST_LABEL ); + iContainer->UpdateLabelL( + ETextArtist, *unknownArtistText ); + CleanupStack::PopAndDestroy( unknownArtistText ); + } + } + else + { + // Display unknown artist as artist + HBufC* unknownArtistText = + StringLoader::LoadLC( R_MPX_PBV_UNKNOWN_ARTIST_LABEL ); + iContainer->UpdateLabelL( + ETextArtist, *unknownArtistText ); + CleanupStack::PopAndDestroy( unknownArtistText ); + } + +#ifdef RD_RA_SUPPORT_FOR_MUSIC_PLAYER + if ( iMedia->IsSupported( KMPXMediaGeneralMimeType ) ) + { + // Get mime type + const TDesC& mimeType = iMedia->ValueText( + KMPXMediaGeneralMimeType ); + const TBool realAudioMode = + ( mimeType.Compare( KMPXPnRealAudioMimeType ) == 0 ) || + ( mimeType.Compare( KMPXRealAudioMimeType ) == 0) || + ( mimeType.Compare( KMPXRnRealAudioMimeType ) == 0 ); + + // Set the real audio mode + iContainer->SetRealAudioMode( realAudioMode ); + } +#endif + } + else + { + // Display nothing if properties is NULL + iContainer->UpdateLabelL( + ETextTrack, KNullDesC ); + iContainer->UpdateLabelL( + ETextArtist, KNullDesC ); +#ifdef RD_RA_SUPPORT_FOR_MUSIC_PLAYER + // reset real audio mode + iContainer->SetRealAudioMode( EFalse ); +#endif + } + } + } + +// --------------------------------------------------------------------------- +// Update current playback state. +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::UpdatePlaybackStateL( + TMPXPlaybackState aPlaybackState ) + { + MPX_DEBUG2("CMPXCommonPlaybackViewImp::UpdatePlaybackState(%d): Entering", aPlaybackState); + + if ( iContainer && !iSwitchingView ) + { + TMPXPbvPlaybackMode mode( EInvalidMode ); + + switch ( aPlaybackState ) + { + case EPbStateNotInitialised: + { + mode = iPlaybackUtility->Source() ? EUninitialized: ENoTracksMode; + break; + } + case EPbStateInitialising: + { + mode = EInitialising; + break; + } + case EPbStatePlaying: + { + mode = EPlayMode; + iIgnoredByUsbEvent = EFalse; + break; + } + case EPbStatePaused: + { + mode = EPauseMode; + break; + } + case EPbStateStopped: + { + mode = EStopMode; + break; + } + case EPbStateBuffering: + { + mode = EBufferingMode; + break; + } + default: + { + // Pass + break; + } + } + + if ( EInvalidMode != mode ) + { + iPlaybackState = aPlaybackState; + iContainer->SetMode( mode ); + } + + iContainer->UpdateButtons( aPlaybackState ); + } + else + { + // If no container, just need to update state + switch ( aPlaybackState ) + { + case EPbStateNotInitialised: + case EPbStateInitialising: + case EPbStatePlaying: + case EPbStatePaused: + case EPbStateStopped: + { + iPlaybackState = aPlaybackState; + break; + } + default: + { + // Pass + // Ignore other state changes such as skipping, etc. + break; + } + } + } + MPX_DEBUG1("CMPXCommonPlaybackViewImp::UpdatePlaybackState(): Exiting"); + } + +// --------------------------------------------------------------------------- +// Updates track's playback position. +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::UpdateTrackPlaybackPositionL( + TInt aPos, + TInt aDuration ) + { + MPX_FUNC_EX( "CMPXCommonPlaybackViewImp::UpdateTrackPlaybackPosition" ); + + if ( iContainer && !iSwitchingView ) + { + if ( aPos > aDuration ) + { + aPos = aDuration; + } + switch ( iPlaybackState ) + { + case EPbStatePaused: + case EPbStatePlaying: + { + iContainer->UpdateTimeIndicatorsL( aPos, aDuration ); + break; + } + case EPbStateStopped: + case EPbStateInitialising: + { + iContainer->UpdateTimeIndicatorsL( aPos, aDuration ); + } // falls through + case EPbStateNotInitialised: + { + iContainer->UpdateDurationLabelL( aDuration ); + break; + } + default: + { + // Do nothing + break; + } + } + } + } + +// --------------------------------------------------------------------------- +// Updates track's album art. +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::UpdateAlbumArtL( + const CMPXMedia* aMedia ) + { + MPX_FUNC_EX( "CMPXCommonPlaybackViewImp::UpdateAlbumArt" ); + + if ( iContainer && !iSwitchingView ) + { + TInt err( KErrNone ); + if ( aMedia && aMedia->IsSupported(KMPXMediaGeneralUri)) + { + const TDesC& album = aMedia->ValueText( KMPXMediaGeneralUri ); + if(!iOldUri || iOldUri->Compare(album)!= 0) + { + TRect albumArtRect( iLayout->IndicatorLayout( ClientRect(), EAlbumArtArea )); + // Request for pre-generated TN size + MPX_TRAP( err, + iMPXUtility->ExtractAlbumArtL( + *aMedia, + *iContainer, + albumArtRect.Size() ); ); + + // cancel timer + if ( iTNRequestTimer->IsActive()) + { + iTNRequestTimer->Cancel(); + } + + if ( err == KErrNone ) + { + // startup timer for updating album art with custom size + TCallBack cb( HandleTNRequestForCustomSizeL, this ); + iTNRequestTimer->Start( KMPXDelayForTNRequest, + KMPXDelayForTNRequest, + cb ); + } + } + + delete iOldUri; + iOldUri = NULL; + iOldUri = album.AllocL(); + } + + if (KErrNone != err ) + { + // If error, show default album art + MPX_DEBUG2("CMPXCommonPlaybackViewImp::UpdateAlbumArt(): err = %d", err); + iContainer->ExtractAlbumArtCompleted( NULL, KErrNone ); + } + } + } + +// --------------------------------------------------------------------------- +// Updates track position in playlist field. +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::UpdateTrackPosInPlaylistL() + { + MPX_FUNC_EX( "CMPXCommonPlaybackViewImp::UpdateTrackPosInPlaylist" ); + + if ( iContainer && !iSwitchingView ) + { + TBool emptyCount( EFalse ); + TInt count( 0 ); + TInt index( 0 ); + + MMPXSource* s = iPlaybackUtility->Source(); + if ( s ) + { + CMPXCollectionPlaylist* playlist = s->PlaylistL(); + if ( playlist ) + { + count = playlist->Count(); + index = playlist->PathIndex( playlist->Index() ); + delete playlist; + playlist = NULL; + } + } + MPX_DEBUG3("CMPXCommonPlaybackViewImp::UpdateTrackPosInPlaylistL: index = %d, count = %d", index, count ); + + // not display for progressive mode & embedded track mode + TMPXLaunchMode mode = MPXTlsHelper::LaunchMode(); + + if ( count ) + { + if ( EMPXLaunchModeTrack != mode ) + { + // Current index (1-based) if playlist is non-empty + // Magic: array granularity + CArrayFixFlat* params = + new ( ELeave ) CArrayFixFlat( 2 ); + CleanupStack::PushL( params ); + params->AppendL( index + 1 ); + params->AppendL( count ); + HBufC* plcounter = StringLoader::LoadLC( + R_MPX_PBV_PLAYLIST_ITEM_COUNTER_LABEL, *params ); + iContainer->UpdateLabelL( + ETextPlaylistCount, + *plcounter ); + CleanupStack::PopAndDestroy( plcounter ); + CleanupStack::PopAndDestroy( params ); + //iContainer->UpdateLabelL( ETextEmpty, KNullDesC ); + } + else + { + emptyCount = ETrue; + } + } + else + { + emptyCount = ETrue; + + // Display empty state text + //HBufC* noTracksText = + // StringLoader::LoadLC( R_MPX_PBV_NO_TRACKS_LABEL ); + //iContainer->UpdateLabelL( + // ETextEmpty, *noTracksText ); + //CleanupStack::PopAndDestroy( noTracksText ); + } + + if ( emptyCount ) + { + // Empty string if playlist is empty + iContainer->UpdateLabelL( + ETextPlaylistCount, + KNullDesC ); + } + } + } + +// --------------------------------------------------------------------------- +// Updates download state label. +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::UpdateDownloadStateLabelL() + { + MPX_FUNC_EX( "CMPXCommonPlaybackViewImp::UpdateDownloadStateLabelL" ); + // Do not show opening popup + } + +// --------------------------------------------------------------------------- +// Updates Title Pane. +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::UpdateTitlePaneL() + { + MPX_FUNC_EX( "CMPXCommonPlaybackViewImp::UpdateTitlePaneL" ); + + CAknTitlePane* title( static_cast + ( StatusPane()->ControlL( TUid::Uid( EEikStatusPaneUidTitle )))); + if ( title ) + { + HBufC* titleText( StringLoader::LoadLC( + R_MPX_PLAYBACKVIEW_TITLE )); + title->SetTextL( *titleText ); + CleanupStack::PopAndDestroy( titleText ); + } + } + +// --------------------------------------------------------------------------- +// Updates FM Transmitter Info +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::UpdateFMTransmitterInfoL( + TBool aForceUpdate ) + { + MPX_FUNC_EX( "CMPXCommonPlaybackViewImp::UpdateFMTransmitterInfoL" ); + + if ( iContainer && !iSwitchingView ) + { + if ( FeatureManager::FeatureSupported( KFeatureIdFmtx ) ) + { + // if FM Transmitter is supported feature, retrieve the state of + // the FM Transmitter + TInt value(EFmTxStateUnknown); + TInt freqKHz = 0; + + if ( iPSKeyWatcher->GetValue( value ) == KErrNone ) + { + MPX_DEBUG2( "CMPXCommonPlaybackViewImp::UpdateFMTransmitterInfoL iPSKeyWatcher value %d", value); + // EFmTxStatePowerSaveAccessory & EFmTxStatePowerSaveInactivity + // are considered as off + if ( value == EFmTxStateActive || + value == EFmTxStateInactive ) + { + // if FM Transmitter is turned on, retrieve the frequency + MPX_TRAPD( err, freqKHz = iCRWatcher->CurrentValueL() ); + if ( err != KErrNone ) + { + freqKHz = 0; + } + } + } + iFmTxActivity = value; + + MPX_DEBUG4( "CMPXCommonPlaybackViewImp::UpdateFMTransmitterInfoL iFMTxFreqKHz %d freqKHz %d aForceUpdate %d", iFMTxFreqKHz, freqKHz, aForceUpdate); + if ( iFMTxFreqKHz != freqKHz || aForceUpdate ) + { + // if the FM Transmitter state has been changed from one active + // to another and it's frequency value changed, or if FM + // Transmitter is changed from an active to an inactive state, + // or vice versa, update the frequency display and save the new + // value + iFMTxFreqKHz = freqKHz; + + // Create display string and default it to an empty string + RBuf freqTxt; + freqTxt.Assign( NULL ); + + CleanupClosePushL( freqTxt ); + + // display the frequncy if it's a valid value + if ( iFMTxFreqKHz > 0 ) + { + TReal freqMHz = static_cast (iFMTxFreqKHz) / + static_cast (KMPXOneMhzInOneKhz); + + TRealFormat realFormat( + KMPXFMFreqWidth, + KMPXFMFreqDecimalPlace); + + // display frequecy as : XXX.XX Mhz + TBuf freqMHzStr; + TInt err = freqMHzStr.Num( freqMHz, realFormat ); + if ( err > 0 ) + { + AknTextUtils::LanguageSpecificNumberConversion( freqMHzStr ); + HBufC* labelFormatText = StringLoader::LoadL( + R_MPX_FM_FREQUENCY_LABEL, + freqMHzStr ); + + // ownership transferred + freqTxt.Assign(labelFormatText); + } + } + + iContainer->UpdateLabelL( + ETextFMFrequency, freqTxt ); + + CleanupStack::PopAndDestroy( &freqTxt ); + } + } + } + } + +// --------------------------------------------------------------------------- +// Handle playback message. +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::DoHandlePlaybackMessageL( + const CMPXMessage& aMessage ) + { + MPX_FUNC_EX("CMPXCommonPlaybackViewImp::DoHandlePlaybackMessageL"); + + TMPXMessageId id( aMessage.ValueTObjectL( KMPXMessageGeneralId ) ); + if ( KMPXMessagePbMediaChanged == id ) + { + MPX_DEBUG1("CMPXCommonPlaybackViewImp::DoHandlePlaybackMessageL: PbMediaChanged"); + if ( aMessage.IsSupported( KMPXMessagePbMedia ) ) + { + CMPXMedia* media( aMessage.Value( KMPXMessagePbMedia ) ); + User::LeaveIfNull( media ); + DoHandleMediaL( *media, KErrNone ); + } + } + else if ( KMPXMessageGeneral == id ) + { + TInt type( aMessage.ValueTObjectL( KMPXMessageGeneralType ) ); + TInt data( aMessage.ValueTObjectL( KMPXMessageGeneralData ) ); + switch ( aMessage.ValueTObjectL( KMPXMessageGeneralEvent ) ) + { + case TMPXPlaybackMessage::EPropertyChanged: + { + MPX_DEBUG2( "CMPXCommonPlaybackViewImp::DoHandlePlaybackMessageL - EPropertyChanged(%d)", type ); + TMPXPlaybackProperty property( + static_cast( type ) ); + TInt error( KErrNone ); + + DoHandlePropertyL( property, data, error ); + break; + } + case TMPXPlaybackMessage::EStateChanged: + { + MPX_DEBUG2( "CMPXCommonPlaybackViewImp::DoHandlePlaybackMessageL - EStateChanged(%d)", type ); + + TMPXPlaybackState state = + static_cast( type ); + if ( ( data == KErrNotSupported ) && + ( state == EPbStatePaused ) ) + { + if ( iLastPBViewActivated ) + { + // In UPnP case, this will display an error message + iCommandSender = ECsMediaKey; + IsCommandSupportedL(); + } + } + else if ( (( data == KErrAccessDenied ) || ( data == KErrDied ) || ( data == KErrInUse )) && + ( state == EPbStatePaused )) + { + if ( iLastPBViewActivated && + MPXUser::IsCallOngoing( EPSCTsyCallTypeH324Multimedia )) + { + iCommonUiHelper->HandleErrorL( KMPXErrorVideoCall ); + } + } + else + { + DoHandleStateChangedL( state, data ); + } + break; + } + case TMPXPlaybackMessage::EMediaChanged: + { + MPX_DEBUG1( "CMPXCommonPlaybackViewImp::DoHandlePlaybackMessageL - EMediaChanged()"); + RequestMediaL(); + if ( iIdle ) + { + if ( iIdle->IsActive() ) + { + MPX_DEBUG1( "CMPXCommonPlaybackViewImp::DoHandlePlaybackMessageL() iIdle active, canceling" ); + iIdle->Cancel(); + } + delete iIdle; + iIdle = NULL; + } + break; + } + case TMPXPlaybackMessage::ECommandReceived: + { + MPX_DEBUG2( "CMPXCommonPlaybackViewImp::DoHandlePlaybackMessageL - ECommandReceived(%d)", type ); + break; + } + case TMPXPlaybackMessage::ESkipping: + { + MPX_DEBUG2( "CMPXCommonPlaybackViewImp::DoHandlePlaybackMessageL - ESkipping(%d)", data ); + if ( iContainer ) + { + iContainer->SetMode( EMediaKeySkipping ); + } + TInt offset( data ); + if ( offset < 0 ) + { + iLastSkipDirection = -1; + } + else + { + iLastSkipDirection = 1; + } + iSkipping = ETrue; + break; + } + case TMPXPlaybackMessage::ESkipEnd: + { + MPX_DEBUG1( "CMPXCommonPlaybackViewImp::DoHandlePlaybackMessageL - ESkipEnd()"); + iSkipping = EFalse; + break; + } + case TMPXPlaybackMessage::EPlaylistUpdated: + { + MPX_DEBUG1( "CMPXCommonPlaybackViewImp::DoHandlePlaybackMessageL - EPlaylistUpdated()"); + // Do not retrive media again if in the middle of handling an error + if ( KErrNone == iDelayedError ) + { + TBool noTracks( ETrue ); + MMPXSource* source = iPlaybackUtility->Source(); + if ( source ) + { + CMPXCollectionPlaylist* pl( source->PlaylistL() ); + if ( pl ) + { + CleanupStack::PushL( pl ); + if ( pl->Count() > 0 ) + { + // Only update media if in foreground + if ( iContainer ) + { + RequestMediaL(); + } + else + { + // If in background, wait for view to be activated + // before requesting media again + delete iMedia; + iMedia = NULL; + } + noTracks = EFalse; + } + CleanupStack::PopAndDestroy( pl ); + } + } + if ( noTracks ) + { + delete iMedia; + iMedia = NULL; + iPlaybackState = EPbStateNotInitialised; + UpdateViewL(); + } + } + break; + } + case TMPXPlaybackMessage::EInitializeComplete: + { + // Reset flag, done opening new item. + MPX_DEBUG1("CMPXCommonPlaybackViewImp::DoHandlePlaybackMessageL()"); + MPX_DEBUG1(" > EInitializeComplete Reset New Item Opened Flag"); + iNewItemOpened = EFalse; + break; + } + default: + { + MPX_DEBUG4("CMPXCommonPlaybackViewImp::DoHandlePlaybackMessageL(): Ignore message %d %d %d", + aMessage.ValueTObjectL( KMPXMessageGeneralEvent ), type, data); + break; + } + } + } + } + +// --------------------------------------------------------------------------- +// Handle playback property. +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::DoHandlePropertyL( + TMPXPlaybackProperty aProperty, + TInt aValue, + TInt aError ) + { + MPX_FUNC_EX( "CMPXCommonPlaybackViewImp::DoHandlePropertyL" ); + MPX_DEBUG4( "HandlePropertyL - Property(%d); Value(%d); Error(%d)", aProperty, aValue, aError ); + + if ( KErrNone == aError ) + { + switch ( aProperty ) + { + case EPbPropertyPosition: + { + iPosition = aValue / KMPXOneSecInMilliSecs; + if( !iIsTapped ) + { + UpdateTrackPlaybackPositionL( iPosition, iDuration ); + break; + } + else + { + iIsTapped = EFalse; + // retrieve iCurrentPlayerType info + GetCurrentPlayerDetails(); + if ( iCurrentPlayerType == EPbRemote ) + { + UpdateTrackPlaybackPositionL( iOldPosition, iDuration ); + break; + } + else + { + UpdateTrackPlaybackPositionL( iPosition, iDuration ); + break; + } + } + } + case EPbPropertyDuration: + { + iDuration = aValue / KMPXOneSecInMilliSecs; + break; + } + case EPbPropertyRandomMode: + { + iRandomMode = aValue; + if ( iContainer ) + { + iContainer->SetRandomMode( aValue ); + } + break; + } + case EPbPropertyRepeatMode: + { + iRepeatMode = aValue; + if ( iContainer ) + { + iContainer->SetRepeatMode( + EPbRepeatAll == aValue, EPbRepeatOne == aValue ); + } + break; + } + default: + { + break; + } + } + } + else + { + HandleErrorL( aError ); + } + } + +// --------------------------------------------------------------------------- +// Handle media properties. +// Notes: The client is responsible for delete the object of aProperties. +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::DoHandleMediaL( + const CMPXMedia& aMedia, + TInt aError ) + { + MPX_FUNC_EX( "CMPXCommonPlaybackViewImp::DoHandleMediaL" ); + MPX_DEBUG2("CMPXCommonPlaybackViewImp::DoHandleMediaL(): aError = %d", aError); + + delete iMedia; + iMedia = NULL; + if ( KErrNone == aError ) + { + iMedia = CMPXMedia::NewL( aMedia ); + + UpdateTrackPosInPlaylistL(); + UpdateTrackInfoL( iMedia ); + UpdateAlbumArtL( iMedia ); + + + // Update duration if previously not available + if ( iMedia->IsSupported( KMPXMediaGeneralDuration ) ) + { + iDuration = iMedia->ValueTObjectL( KMPXMediaGeneralDuration ) / + KMPXOneSecInMilliSecs; + UpdateTrackPlaybackPositionL( iPosition, iDuration ); + } + + // If there's a delayed error, handle it now + // that the media object has arrived + if ( iDelayedError != KErrNone ) + { + // if repeat mode is off, delay to handle this error. + if ( EPbRepeatOff == iRepeatMode ) + { + // save current index + iErrIndex = KErrNotFound; + if (iPlaybackUtility) + { + MMPXSource* source( iPlaybackUtility->Source() ); + if ( source ) + { + CMPXCollectionPlaylist* pl( source->PlaylistL() ); + if ( pl ) + { + CleanupStack::PushL( pl ); + iErrIndex = pl->Index(); + CleanupStack::PopAndDestroy( pl ); + } + } + } + // startup timer for handling delayed error + TCallBack cb( HandleDelayedError, this ); + if (iDelayedErrorTimer->IsActive()) + { + iDelayedErrorTimer->Cancel(); + } + iDelayedErrorTimer->Start( KMPXPostponeForHandleDelayedError, + KMPXPostponeForHandleDelayedError, + cb ); + // reset iDelayedError + iLastDelayedErr = iDelayedError; + iDelayedError = KErrNone; + } + else + { + // if repeat mode isn't off, handle it at once. + if (iDelayedErrorTimer->IsActive()) + { + iDelayedErrorTimer->Cancel(); + } + + // Copy error code and reset iDelayedError, this is becuase + // a media event may be called while handling this error + TInt err( iDelayedError ); + iDelayedError = KErrNone; + HandleErrorL( err ); + } + } + } + else + { + +#ifndef CAMESE_IN_DRM_UTILITY + // Check if Camese Support is enabled and + // if the error is caused by PV being unable + // to retrieve media properties before handling + // the error here. + if (iCameseSuperDistSupport && aError == KErrPermissionDenied) + { + // Clear delayed errors. + iDelayedError = KErrNone; + return; + } +#endif + HandleErrorL(aError); + + if ( aError == iDelayedError ) + { + iDelayedError = KErrNone; + } + } + } + +// --------------------------------------------------------------------------- +// Handle playback state changed. +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::DoHandleStateChangedL( + TMPXPlaybackState aState, + TInt aData ) + { + MPX_FUNC_EX( "CMPXCommonPlaybackViewImp::DoHandleStateChangedL" ); + MPX_DEBUG2( "CMPXCommonPlaybackViewImp::DoHandleStateChangedL %d", aState ); + UpdatePlaybackStateL( aState ); + + switch ( aState ) + { + case EPbStateStopped: + case EPbStateNotInitialised: + { + iPosition = 0; + UpdateTrackPlaybackPositionL( iPosition, iDuration ); + break; + } + case EPbStateInitialising: + { + // Save the start playback index + if ( KErrNotFound == iStartPlaybackIndex && + KErrNotFound != aData ) + { + iStartPlaybackIndex = aData; + } + UpdateDownloadStateLabelL(); + iDelayedErrorTimer->Cancel(); + break; + } + case EPbStatePlaying: + case EPbStatePaused: + default: + { + MPX_PERF_CHECKPT("Playback state changes to Play/Pause"); + iStartPlaybackIndex = KErrNotFound; + iLastSkipDirection = 1; + break; + } + } + } + +// --------------------------------------------------------------------------- +// Get simple embedded mode. +// --------------------------------------------------------------------------- +// +EXPORT_C TBool CMPXCommonPlaybackViewImp::SimpleEmbeddedMode() const + { + return iEmbedded; + } + +// --------------------------------------------------------------------------- +// Get embedded status. +// --------------------------------------------------------------------------- +// +EXPORT_C TBool CMPXCommonPlaybackViewImp::IsEmbedded() const + { + return iEmbedded; + } + +// --------------------------------------------------------------------------- +// Displays error notes. +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::HandleErrorL( TInt aError ) + { + MPX_DEBUG2( "CMPXCommonPlaybackViewImp::HandleErrorL(%d): Entering", aError ); + MPX_DEBUG2( "CMPXCommonPlaybackViewImp::HandleErrorL iIgnoredByUsbEvent(%d):", iIgnoredByUsbEvent ); + if ( aError ) + { + TInt currentIndex( KErrNotFound ); + TInt nextIndex( KErrNotFound ); + TInt plCount( KErrNotFound ); + MMPXSource* source( iPlaybackUtility->Source() ); + if ( source ) + { + CMPXCollectionPlaylist* pl( source->PlaylistL() ); + if ( pl ) + { + CleanupStack::PushL( pl ); + currentIndex = pl->Index(); + if ( iLastSkipDirection < 0 ) + { + pl->Previous( ETrue ); + } + else + { + pl->Next( ETrue ); + } + nextIndex = pl->Index(); + plCount = pl->Count(); + CleanupStack::PopAndDestroy( pl ); + } + } + + // MMF framework will return KErrArgument/KErrCompletion if it reaches + // the end of a partially downloaded file. The downloaded portion of + // the file should still be playable in this case. + if ( KErrNotFound != nextIndex && !iIgnoredByUsbEvent && + KErrDisMounted != aError && + ( ( KErrArgument != aError && KErrCompletion != aError ) || + iPlaybackState != EPbStatePlaying )) + { + // Check if all tracks are invalid, or if there's only + // 1 track in the playlist + if ( nextIndex == iStartPlaybackIndex || + plCount == 1 || + EPbRepeatOne == iRepeatMode) + { + aError = KMPXAllTracksInvalid; + } + } + + // Igore these messages when USB event just happened + if (iIgnoredByUsbEvent && + (aError == KErrCANoRights || + aError == KErrPathNotFound || + aError == KErrDisMounted ) + ) + { + iIgnoredByUsbEvent = EFalse; + return; + } + + // else iIgnoredByUsbEvent==EFalse, then furtherly check USB status in central repository. + else if ( !iIgnoredByUsbEvent ) + { + TInt usbStatus; + RProperty::Get( KPSUidUsbWatcher, KUsbWatcherSelectedPersonality, usbStatus ); + + if ( KUsbPersonalityIdMS == usbStatus && KErrDisMounted == aError ) + { + // Igore this error when USB is avtive in MassStrorage mode. + return; + } + } + + switch ( aError ) + { + case KMPXRightsAboutToExpire: + case KErrCANotSupported: + case KErrCANoPermission: + case KErrCANoRights: + case KErrCANoAgent: + case KErrCAOutOfRange: + case KErrCAPendingRights: + case KErrCASizeNotDetermined: + case KErrCANewFileHandleRequired: + case KErrPermissionDenied: + { + if (aError == KErrCANoPermission || + aError == KErrCANoRights) + { + iCommonUiHelper->HandleErrorL( KMPXErrorExpiredRights, iMedia ); + } + TBool skip(ETrue); + + if ( iMedia ) + { + if ( iMedia->IsSupported( KMPXMediaDrmType ) ) + { + TMPXMediaDrmType type( + iMedia->ValueTObjectL( + KMPXMediaDrmType ) ); + + // Only display DRM error message for WMDRM + // if it's the first song selected + if ( EMPXDrmTypeWMA == type && + currentIndex == iStartPlaybackIndex) + { +#ifndef CAMESE_IN_DRM_UTILITY + MPX_DEBUG2("CMPXCommonPlaybackViewImp::HandleErrorL iCameseSuperDistSupport %d", iCameseSuperDistSupport); + // Only handle the error if Camese is disabled. + if (!iCameseSuperDistSupport) + { + MPX_DEBUG2("CMPXCommonPlaybackViewImp::HandleErrorL iNewItemOpened %d", iNewItemOpened); + if (iNewItemOpened) + { + iPlaybackUtility->CommandL( EPbCmdStop ); + iCommonUiHelper->HandleErrorL( aError, iMedia ); + // If Camese is off and we + // received the collection message + // indicating we are opening a new item, + // disable skipping on this error. + // We just stop playback. + skip = EFalse; + + // Reset the Start Playback Index. + iStartPlaybackIndex = KErrNotFound; + } + } + else if (iNewItemOpened) +#else + if (iNewItemOpened) +#endif + { + MPX_DEBUG1("CMPXPlaybackViewImp::HandleErrorL Skip Disabled - New Item"); + + // If Camese is on and we + // received the collection message + // indicating we are opening a new item, + // disable skipping on this error. Camese will handle + // postdelivery in this case. + skip = EFalse; + + // Reset the Start Playback Index. + iStartPlaybackIndex = KErrNotFound; + } + } + } + } + + if (skip) + { + SkipOnErrorL( currentIndex, plCount ); + } + break; + } + case KErrAccessDenied: + { + // Only display error message if first one selected to play + if ( currentIndex == iStartPlaybackIndex ) + { + iCommonUiHelper->HandleErrorL( aError, iMedia ); + } + SkipOnErrorL( currentIndex, plCount ); + break; + } + case KErrNotSupported: + case KErrCorrupt: + case KErrNotFound: + case KErrPathNotFound: + case KErrDivideByZero: + case KErrGeneral: + { + // USB dismounts the disk, it cannot find any records + if( !iDatabaseNotReady ) + { + SkipOnErrorL( currentIndex, plCount ); + } + break; + } + case KMPXAllTracksInvalid: + { + HandleAllTracksInvalidL(); + break; + } + case KErrArgument: + case KErrCompletion: + { + TBool skip( ETrue ); + + // UI specs say theres two cases where it stops and + // does not skip to the next song. + // First case is if not repeat all and playback has + // reached the end of the list and gone to the first song. + // Second case is if not repeat all and the user is skipping + // backwards and reached the first song + if ( EPbRepeatAll != iRepeatMode && + 0 == currentIndex && + -1 == iLastSkipDirection) + { + skip = EFalse; + } + + // Skip to next/previous track + if ( skip ) + { + if ( iLastSkipDirection < 0 ) + { + iPlaybackUtility->CommandL( EPbCmdPrevious ); + } + else + { + iPlaybackUtility->CommandL( EPbCmdNext ); + } + } + break; + } + case KErrDiskFull: + { + iCommonUiHelper->HandleErrorL( aError, iMedia ); + break; + } + default: + { + iPlaybackUtility->CommandL( EPbCmdStop ); + iCommonUiHelper->HandleErrorL( aError, iMedia ); + break; + } + } + } + + // Reset flag after error handling is done. + MPX_DEBUG1("CMPXPlaybackViewImp::HandleErrorL()"); + MPX_DEBUG1(" > Reset New Item Opened Flag"); + iNewItemOpened = EFalse; + iErrorOccured = EFalse; + MPX_DEBUG1( "CMPXCommonPlaybackViewImp::HandleErrorL: Exiting"); + } + +// --------------------------------------------------------------------------- +// Displays error note for when all tracks are invalid, +// and goes back to collection list view +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::HandleAllTracksInvalidL() + { + MPX_DEBUG1("CMPXCommonPlaybackViewImp::HandleAllTracksInvalidL: Entering"); + MPX_DEBUG2("CMPXCommonPlaybackViewImp::HandleAllTracksInvalidL: iDatabaseNotReady (%d)", iDatabaseNotReady); + + iPlaybackUtility->CommandL( EPbCmdStop ); + UpdatePlaybackStateL( EPbStateStopped ); + + TInt mpxWindowGroupId = CEikonEnv::Static()->RootWin().Identifier(); + + // Usb event happened. + if (iDatabaseNotReady) + { + iIgnoredByUsbEvent = ETrue; + } + + // Do not display error if view is not active + if ( iContainer && !iDatabaseNotReady && + iCommonUiHelper->IsForegroundApplication(mpxWindowGroupId) && + iViewUtility->ActiveViewType() != TUid::Uid( KMPXPluginTypeEqualizerUid ) ) + { + iCommonUiHelper->HandleErrorL( KMPXAllTracksInvalid, iMedia ); + + // Check foreground again just in case of user presses end key and switch + // to idle application while error notes are showing + // do not switch view when USB events ongoing + if (!iDatabaseNotReady && + iCommonUiHelper->IsForegroundApplication(mpxWindowGroupId)) + { + HandleCommandL( EAknSoftkeyBack ); + } + + iStartPlaybackIndex = KErrNotFound; + iLastSkipDirection = 1; + + // Reset the playlist to point to the first item + // in list, but do not initialize the song for + // playback + MMPXSource* source( iPlaybackUtility->Source() ); + if ( source ) + { + CMPXCollectionPlaylist* pl( source->PlaylistL() ); + if ( pl ) + { + CleanupStack::PushL( pl ); + pl->SetToFirst(); + iPlaybackUtility->InitL( *pl, EFalse ); + CleanupStack::PopAndDestroy( pl ); + } + } + } + + + MPX_DEBUG1("CMPXCommonPlaybackViewImp::HandleAllTracksInvalidL: Exiting"); + } + +// --------------------------------------------------------------------------- +// Checks whether or not to skip to next track on an error +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::SkipOnErrorL( + TInt aCurrentIndex, + TInt aCount ) + { + MPX_DEBUG3("CMPXCommonPlaybackViewImp::SkipOnErrorL(%d %d): Entering", aCurrentIndex, aCount); + + TBool skip( ETrue ); + TBool displayError( EFalse ); + + // If playlist is invalid, don't skip. Fix for error EJPJ-7CVAJX. + if ( aCurrentIndex == KErrNotFound && aCount == KErrNotFound ) + { + skip = EFalse; + iCommonUiHelper->HandleErrorL( KErrCorrupt ); + } + // UI specs say theres two cases where it stops and + // does not skip to the next song. + // First case is if not repeat all and playback has + // reached the end of the list and gone to the first song. + // Second case is if not repeat all and the user is skipping + // backwards and reached the first song + else if ( EPbRepeatAll != iRepeatMode ) + { + if ( 0 == aCurrentIndex && + -1 == iLastSkipDirection ) + { + skip = EFalse; + displayError = ETrue; + } + else if ( aCurrentIndex == aCount-1 && + 1 == iLastSkipDirection ) + { + skip = EFalse; + displayError = ETrue; + } + } + if ( EPbRepeatAll == iRepeatMode ) + { + if ( aCurrentIndex == aCount-1 && + 1 == iLastSkipDirection && + 1 != iRandomMode ) + { + skip = EFalse; + displayError = ETrue; + } + } + + // Skip to next/previous track + if ( skip ) + { + if ( iLastSkipDirection < 0 ) + { + iPlaybackUtility->CommandL( EPbCmdPrevious ); + } + else + { + iPlaybackUtility->CommandL( EPbCmdNext ); + } + } + + // Display error message + if ( displayError ) + { + HandleAllTracksInvalidL(); + } + + MPX_DEBUG1("CMPXCommonPlaybackViewImp::SkipOnErrorL: Exiting"); + } + +// --------------------------------------------------------------------------- +// Function to display information notes +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::DisplayInfoNoteL( TInt aResourceId ) + { + HBufC* text = StringLoader::LoadLC( aResourceId ); + CAknInformationNote* dlg = new ( ELeave ) CAknInformationNote( ETrue ); + dlg->ExecuteLD( *text ); + CleanupStack::PopAndDestroy( text ); + } + +// --------------------------------------------------------------------------- +// Function to display confirmation notes +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::DisplayConfirmionNoteL( TInt aResourceId ) + { + HBufC* text = StringLoader::LoadLC( aResourceId ); + CAknConfirmationNote* dlg = new ( ELeave ) CAknConfirmationNote( ETrue ); + dlg->ExecuteLD( *text ); + CleanupStack::PopAndDestroy( text ); + } + +// --------------------------------------------------------------------------- +// Set process priority. +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::SetProcessPriority() + { + RProcess thisProcess; + TProcessPriority pPriority = thisProcess.Priority(); + + // Check if playback state is not playing, set to background + TMPXPlaybackState state( EPbStateNotInitialised ); + TRAP_IGNORE( state = iPlaybackUtility->StateL() ); + + if ( EPbStatePlaying != state && pPriority == EPriorityHigh ) + { + MPX_DEBUG1( "CMPXCommonPlaybackViewImp::SetProcessPriority -- setting process priority to EPriorityBackground" ); + thisProcess.SetPriority( EPriorityBackground ); + } + } + +// --------------------------------------------------------------------------- +// Launch equalizer dialog. +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::LaunchEqualizerL() + { + + // Activate Equalizer dialog via View Framework + iViewUtility->ActivateViewL( TUid::Uid( KMPXPluginTypeEqualizerUid ) ); + + iContainer->SetRect( ClientRect() ); + iContainer->DrawDeferred(); + iSwitchingView = EFalse; + } + + +// --------------------------------------------------------------------------- +// Launch Music Settings view. +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::LaunchMusicSettingsL() + { + // Activate Audio Effects view via View Framework + iViewUtility->ActivateViewL( + TUid::Uid( KMPXPluginTypeAudioEffectsUid ) ); + } + +// --------------------------------------------------------------------------- +// Launch FM Transmitter application +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::LaunchFMTransmitterL() + { + MPX_FUNC_EX( "CMPXCommonPlaybackViewImp::LaunchFMTransmitterL" ); + + if ( FeatureManager::FeatureSupported( KFeatureIdFmtx ) ) + { + TApaTaskList tasList( iCoeEnv->WsSession() ); + TApaTask task = tasList.FindApp( KFmTxAppUid ); + if ( task.Exists() ) + { + GfxTransEffect::BeginFullScreen( + AknTransEffect::EApplicationStart, + TRect(), + AknTransEffect::EParameterType, + AknTransEffect::GfxTransParam( KFmTxAppUid, + AknTransEffect::TParameter::EActivateExplicitContinue )); + task.BringToForeground(); + } + else + { + RProcess process; + TApaAppInfo appInfo; + RApaLsSession session; + if ( KErrNone == session.Connect() ) + { + CleanupClosePushL( session ); + TThreadId threadId; + session.CreateDocument( KNullDesC, KFmTxAppUid, threadId ); + CleanupStack::PopAndDestroy(&session); + } + } + } + } + +// --------------------------------------------------------------------------- +// Request for the media object +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::RequestMediaL( TBool aDrm /*=EFalse*/ ) + { + MPX_DEBUG1("CMPXCommonPlaybackViewImp::RequestMediaL(): entering"); + + MMPXSource* s = iPlaybackUtility->Source(); + if ( s ) + { + RArray attrs; + CleanupClosePushL(attrs); + attrs.Append( KMPXMediaGeneralBasic | + KMPXMediaGeneralUri | + KMPXMediaGeneralMimeType | + KMPXMediaGeneralDuration ); + attrs.Append( KMPXMediaMusicAlbumArtFileName | + KMPXMediaMusicArtist | + KMPXMediaMusicAlbum ); + if ( aDrm ) + { + attrs.Append( KMPXMediaDrmAll ); + } + else + { + // If not retrieving all drm attributes, then + // minimal is retrieve the protected flag and + // automated flag + attrs.Append( KMPXMediaDrmProtected | + KMPXMediaDrmCanSetAutomated ); + } + s->MediaL( attrs.Array(), *this ); + CleanupStack::PopAndDestroy( &attrs ); + } + MPX_DEBUG1("CMPXCommonPlaybackViewImp::RequestMediaL(): exiting"); + } + +// ----------------------------------------------------------------------------- +// CMPXCommonPlaybackViewImp::PrepareStatusPaneForPlaybackViewL +// ----------------------------------------------------------------------------- +// +void CMPXCommonPlaybackViewImp::PrepareStatusPaneForPlaybackViewL() + { + iPreviousStatusPaneLayout = StatusPane()->CurrentLayoutResId(); + TInt resId( KErrNone ); + + // We need to restore the status pane if not visible. + if (!StatusPane()->IsVisible()) + { + StatusPane()->MakeVisible(ETrue); + } + + if ( !Layout_Meta_Data::IsLandscapeOrientation() ) + { + if ( iPreviousStatusPaneLayout != R_AVKON_STATUS_PANE_LAYOUT_USUAL_FLAT ) + { + resId = R_AVKON_STATUS_PANE_LAYOUT_USUAL_FLAT; + } + } + + if ( KErrNone != resId ) + { + CAknLocalScreenClearer* clearer = CAknLocalScreenClearer::NewLC( ETrue ); + StatusPane()->SwitchLayoutL( resId ); + CleanupStack::PopAndDestroy( clearer ); + } + else if ( iContainer ) + { + iContainer->SetRect( ClientRect() ); + } + } + +// ----------------------------------------------------------------------------- +// CMPXCommonPlaybackViewImp::PrepareStatusPaneForExitingViewL +// ----------------------------------------------------------------------------- +// +void CMPXCommonPlaybackViewImp::PrepareStatusPaneForExitingViewL() + { + MPX_FUNC_EX("CMPXCommonPlaybackViewImp::PrepareStatusPaneForExitingViewL()"); + if ( StatusPane()->CurrentLayoutResId() != + iPreviousStatusPaneLayout) + { + StatusPane()->SwitchLayoutL( iPreviousStatusPaneLayout ); + } + } + +// --------------------------------------------------------------------------- +// From MMPXPlaybackObserver +// Handle playback message. +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::HandlePlaybackMessage( + CMPXMessage* aMessage, TInt aError ) + { + MPX_DEBUG2("-->CMPXCommonPlaybackViewImp::HandlePlaybackMessage(): aError = %d", aError); + if ( aError == KErrNone && aMessage ) + { + TRAP_IGNORE( DoHandlePlaybackMessageL( *aMessage ) ); + } + else if ( aError != KErrNone && iLastPBViewActivated ) + { + iErrorOccured = ETrue; + TRAP_IGNORE( DoHandleErrorPlaybackMessageL( aError ) ); + } + MPX_DEBUG2("<--CMPXCommonPlaybackViewImp::HandlePlaybackMessage(): aError = %d", aError); + } + +// --------------------------------------------------------------------------- +// From MMPXPlaybackCallback +// Handle playback property. +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::HandlePropertyL( + TMPXPlaybackProperty aProperty, + TInt aValue, + TInt aError ) + { + TRAP_IGNORE( DoHandlePropertyL( aProperty, aValue, aError ) ); + } + +// --------------------------------------------------------------------------- +// From MMPXPlaybackCallback +// Method is called continously until aComplete=ETrue, signifying that +// it is done and there will be no more callbacks +// Only new items are passed each time +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::HandleSubPlayerNamesL( + TUid /* aPlayer */, + const MDesCArray* /* aSubPlayers */, + TBool /* aComplete */, + TInt /* aError */ ) + { + MPX_FUNC_EX( "CMPXCommonPlaybackViewImp::HandleSubPlayerNamesL" ); + } + +// --------------------------------------------------------------------------- +// From MMPXPlaybackCallback +// Handle media event. +// Notes: The client is responsible for delete the object of aProperties. +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::HandleMediaL( + const CMPXMedia& aMedia, + TInt aError ) + { + MPX_FUNC_EX( "CMPXCommonPlaybackViewImp::HandleMediaL" ); + TRAP_IGNORE( DoHandleMediaL( aMedia, aError )); + } + +// --------------------------------------------------------------------------- +// From MMPXCollectionMediaObserver +// Handle extended media properties +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::HandleCollectionMediaL( + const CMPXMedia& aMedia, + TInt aError ) + { + MPX_FUNC_EX( "CMPXCommonPlaybackViewImp::HandleCollectionMediaL" ); + TRAP_IGNORE( DoHandleMediaL( aMedia, aError )); + } + +// --------------------------------------------------------------------------- +// From CAknView +// Command handling function. +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::HandleCommandL( TInt aCommand ) + { + MPX_DEBUG2( "CMPXCommonPlaybackViewImp::HandleCommandL(%d) entering", aCommand ); + + switch (aCommand) + { + case EAknCmdHelp: + { + HlpLauncher::LaunchHelpApplicationL( + iEikonEnv->WsSession(), + AppUi()->AppHelpContextL() ); + break; + } + case EAknSoftkeyBack: + { + + #ifdef BACKSTEPPING_INCLUDED + // let Back Stepping Service handle the event + TInt statusInfo( KMPXBackSteppingNotConsumed ); + if ( iViewUtility && + ( iViewUtility->ActiveViewType() != KNullUid ) ) + { + TInt viewId( iViewUtility->ActiveViewType().iUid ); + TBuf8 buf; + buf.Copy( KMVPrefix ); + buf.AppendNum( viewId ); + statusInfo = iBackSteppingUtility->HandleBackCommandL( buf ); + MPX_DEBUG3("CMPXCommonPlaybackViewImp::HandleCommandL - viewid=0x%x, statusInfo=%d", + viewId, statusInfo ); + } + if ( statusInfo == KMPXBackSteppingNotConsumed ) + #endif // BACKSTEPPING_INCLUDED + { + if ( !iBacking ) + { + // event not consumed by Back Stepping utility, handle here + + MMPXSource* source = iPlaybackUtility->Source(); + if ( source ) + { + CMPXCollectionPlaylist* playlist = source->PlaylistL(); + if ( playlist ) + { + CleanupStack::PushL( playlist ); + + if ( playlist->Count() ) + { + CMPXCollectionPath* pbPath = CMPXCollectionPath::NewL( playlist->Path() ); + CleanupStack::PushL( pbPath ); + pbPath->Back(); + iViewUtility->PushDefaultHistoryL(); + MPX_DEBUG_PATH(*pbPath); + iCollectionUtility->Collection().OpenL( *pbPath ); + CleanupStack::PopAndDestroy( pbPath ); + } + else + { + // TO-DO: check if collection is empty, activate + // music main menu? or change ui spec + AppUi()->HandleCommandL( EAknSoftkeyBack ); + } + CleanupStack::PopAndDestroy( playlist ); + } + else + { + AppUi()->HandleCommandL( EAknSoftkeyBack ); + } + } + else + { + CMPXCollectionPath* cpath = iCollectionUtility->Collection().PathL(); + CleanupStack::PushL( cpath ); + while ( cpath->Levels() > 2 ) + { + cpath->Back(); + } + iCollectionUtility->Collection().OpenL( *cpath ); + CleanupStack::PopAndDestroy( cpath ); + } + iBacking = ETrue; + } + } + break; + } + case EAknCmdExit: + case EAknSoftkeyExit: + case EEikCmdExit: + { + AppUi()->HandleCommandL( aCommand ); + break; + } + case EMPXPbvCmdGotoMusicMenu: + { + AppUi()->HandleCommandL( EMPXCmdGotoCollection ); + TInt val(0); + CRepository* repository = CRepository::NewL( KCRUidMPXMPFeatures ); + repository->Get( KMPXMPLocalVariation, val ); + TBool startInAlbumMenu = val&KMPXStartMusicPlayerinArtistsandAlbums ? ETrue : EFalse; + delete repository; + + if ( startInAlbumMenu ) + { + CMPXCollectionPath* cpath = iCollectionUiHelper->MusicMenuPathL(); + CleanupStack::PushL( cpath ); + cpath->AppendL(3); // Albums + MPX_DEBUG_PATH(*cpath); + iCollectionUtility->Collection().OpenL( *cpath ); + CleanupStack::PopAndDestroy( cpath ); + } + else + { + // Handle Goto Music menu + CMPXCollectionPath* cpath = iCollectionUiHelper->MusicMenuPathL(); + CleanupStack::PushL( cpath ); + MPX_DEBUG_PATH (*cpath); + iCollectionUtility->Collection().OpenL( *cpath ); + CleanupStack::PopAndDestroy( cpath ); + } + // Make sure status pane layout is usual when going + // directly to music menu + // Status pane has to be modified before view gets deactivated + break; + } + case EMPXPbvCmdSongDetails: + { + if( !iErrorOccured ) + { + LaunchFileDetailsDialogL(); + } + + break; + } + case EMPXPbvCmdPlay: + { + if ( iEmbedded ) + { + iPlaybackUtility->CommandL( EPbCmdDisableEffect ); + } + iPlaybackUtility->CommandL( EPbCmdPlay ); + break; + } + case EMPXPbvCmdStop: + { + iPlaybackUtility->CommandL( EPbCmdStop ); + break; + } + case EMPXPbvCmdPause: + { + MPX_PERF_CHECKPT("Pause command issued"); + iPlaybackUtility->CommandL( EPbCmdPause ); + break; + } + case EMPXPbvCmdPlayPause: + { + iPlaybackUtility->CommandL( EPbCmdPlayPause ); + break; + } + case EMPXPbvCmdSeekForward: + { + iSkipBtnPressed = ETrue; + iCommandSender = ECsRenderer; + if ( IsCommandSupportedL() ) + { + iPlaybackUtility->CommandL( EPbCmdStartSeekForward ); + if ( !iKeySoundDisabled ) + { + iAvkonViewAppUi->KeySounds()->PushContextL( + R_MPX_PBV_LEFT_RIGHT_KEYS_SILENT ); + iKeySoundDisabled = ETrue; + } + } + iUnsupportedNoteDisabled = EFalse; + iIsffButtonPressed = ETrue; + break; + } + case EMPXPbvCmdSeekBackward: + { + iSkipBtnPressed = ETrue; + iCommandSender = ECsRenderer; + if ( IsCommandSupportedL() ) + { + iPlaybackUtility->CommandL( EPbCmdStartSeekBackward ); + if ( !iKeySoundDisabled ) + { + iAvkonViewAppUi->KeySounds()->PushContextL( + R_MPX_PBV_LEFT_RIGHT_KEYS_SILENT ); + iKeySoundDisabled = ETrue; + } + } + iUnsupportedNoteDisabled = EFalse; + iIsffButtonPressed = ETrue; + break; + } + case EMPXPbvCmdEndSeek: + { + iSkipBtnPressed = EFalse; + iIsffButtonPressed = EFalse; + iUnsupportedNoteDisabled = EFalse; + iPlaybackUtility->CommandL( EPbCmdStopSeeking ); + if ( iKeySoundDisabled ) + { + iAvkonViewAppUi->KeySounds()->PopContext(); + iKeySoundDisabled = EFalse; + } + break; + } + case EMPXPbvCmdNextListItem: + { + // When user skips a track, reset the start playback index + iStartPlaybackIndex = KErrNotFound; + iDelayedErrorTimer->Cancel(); + + iPlaybackUtility->CommandL( EPbCmdNext ); + break; + } + case EMPXPbvCmdPreviousListItem: + { + // When user skips a track, reset the start playback index + iStartPlaybackIndex = KErrNotFound; + iDelayedErrorTimer->Cancel(); + + iPlaybackUtility->CommandL( EPbCmdPrevious ); + break; + } + case EMPXPbvCmdDecreaseVolume: + { + iPlaybackUtility->CommandL( EPbCmdDecreaseVolume ); + break; + } + case EMPXPbvCmdIncreaseVolume: + { + iPlaybackUtility->CommandL( EPbCmdIncreaseVolume ); + break; + } + case EMPXPbvCmdPosition: + { + iIsTapped = ETrue; + iCommandSender = ECsRenderer; + if ( IsCommandSupportedL() && ( iCurrentPlayerType != EPbRemote ) ) + { + TInt newPosition = iContainer->GetNewSongPosition(); + iPlaybackUtility->SetL( EPbPropertyPosition, newPosition); + } + else + { + iUnsupportedNoteDisabled = EFalse; + } + break; + } + case EMPXPbvCmdRepeatOne: + { + iPlaybackUtility->SetL( EPbPropertyRepeatMode, EPbRepeatOne ); + break; + } + case EMPXPbvCmdRepeatAll: + { + iPlaybackUtility->SetL( EPbPropertyRepeatMode, EPbRepeatAll ); + break; + } + case EMPXPbvCmdRepeatOff: + { + iPlaybackUtility->SetL( EPbPropertyRepeatMode, EPbRepeatOff ); + break; + } + case EMPXPbvCmdRandomOn: + { + iPlaybackUtility->SetL( EPbPropertyRandomMode, ETrue ); + break; + } + case EMPXPbvCmdRandomOff: + { + iPlaybackUtility->SetL( EPbPropertyRandomMode, EFalse ); + break; + } + case EMPXCmdAfterSaveUseAsCascade: + { + CAiwGenericParamList& paramList = iServiceHandler->InParamListL(); + MPX_DEBUG1( "Todd CMPXCommonPlaybackViewImp::HandleCommandL aCommand=EMPXCmdAfterSaveUseAsCascade" ); + FillAiwParametersL(paramList, ETrue); + iServiceHandler->ExecuteMenuCmdL(EMPXPbvCmdUseAsCascade, paramList, + iServiceHandler->OutParamListL()); + break; + } + // The clip was saved before setting clip as profile ringtone + case EMPXCmdAfterSaveAiwCmdAssign: + { + CAiwGenericParamList& paramList = iServiceHandler->InParamListL(); + MPX_DEBUG1( "Todd CMPXCommonPlaybackViewImp::HandleCommandL aCommand=EMPXCmdAfterSaveAiwCmdAssign" ); + FillAiwParametersL(paramList, ETrue); + iServiceHandler->ExecuteMenuCmdL(EMPXPbvCmdAiwCmdAssign, paramList, + iServiceHandler->OutParamListL()); + break; + } + case EMPXPbvCmdUseAsCascade: + case EMPXPbvCmdAiwCmdAssign: + { + CAiwGenericParamList& paramList = iServiceHandler->InParamListL(); + FillAiwParametersL(paramList, EFalse); + iServiceHandler->ExecuteMenuCmdL(aCommand, paramList, + iServiceHandler->OutParamListL()); + break; + } + case EMPXPbvCmdEqualizer: + { + LaunchEqualizerL(); + break; + } + case EMPXPbvCmdOpenMusicSettings: + { + LaunchMusicSettingsL(); + break; + } + + case EMPXPbvCmdUpnpPlayViaLocal: + { + if ( iUpnpFrameworkSupport ) + { + SelectNewPlayerL( aCommand ); + } + break; + } + case EMPXPbvCmdFMTransmitter: + { + LaunchFMTransmitterL(); + break; + } + case EMPXPbvCmdAddToSavedPlaylist: + { + AddToSavedPlaylistL(); + break; + } + case EMPXPbvCmdAddToNewPlaylist: + { + AddToNewPlaylistL(); + break; + } + case EMPXCmdNext: + case EMPXCmdPrevious: + // When user skips a track, reset the start playback index + iStartPlaybackIndex = KErrNotFound; + case EMPXCmdPlay: + case EMPXCmdPause: + case EMPXCmdPlayPause: + case EMPXCmdStop: + case EMPXCmdSeekForward: + case EMPXCmdSeekBackward: + case EMPXCmdStopSeeking: + { + // check if current view is empty + TInt count( 0 ); + MMPXSource* s = iPlaybackUtility->Source(); + if ( s ) + { + CMPXCollectionPlaylist* playlist = s->PlaylistL(); + if ( playlist ) + { + count = playlist->Count(); + } + delete playlist; + } +#ifdef RD_BROWSER_PROGRESSIVE_DOWNLOAD + AppUi()->HandleCommandL( aCommand ); + count = count; // avoid compilation warning. +#else + if ( count > 0 ) + { + // only handle command if current playlist is not empty + AppUi()->HandleCommandL( aCommand ); + } +#endif + break; + } + case EMPXCmdVolumeUp: + case EMPXCmdVolumeDown: + case EMPXCmdVolumeMute: + case EMPXCmdVolumeUnMute: + case EMPXCmdVolumeChanged: + { + //Do not try to update volume if FMTx (transmission) is on. + if (iFmTxActivity != EFmTxStateActive) + { + AppUi()->HandleCommandL( aCommand ); + } + break; + } + default: + { + if ( iUpnpFrameworkSupport ) + { + if ( aCommand >= EMPXPbvCmdUpnpPlayViaRemotePlayer ) + { + SelectNewPlayerL( aCommand ); + } + else + { + AppUi()->HandleCommandL( aCommand ); + } + } + else + { + AppUi()->HandleCommandL( aCommand ); + } + break; + } + } + MPX_DEBUG1( "CMPXCommonPlaybackViewImp::HandleCommandL() exiting" ); + } + +// --------------------------------------------------------------------------- +// From CAknView +// Processes user commands. +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::ProcessCommandL( TInt aCommand ) + { + MPX_DEBUG2("CMPXCommonPlaybackViewImp::ProcessCommandL(%d): entering", aCommand); + if ( aCommand == EAknCmdExit ) + { + if ( MenuBar() ) + { + MenuBar()->StopDisplayingMenuBar(); + } + HandleCommandL( aCommand ); + } + CAknView::ProcessCommandL( aCommand ); + MPX_DEBUG1("CMPXCommonPlaybackViewImp::ProcessCommandL(): exiting"); + } + +// --------------------------------------------------------------------------- +// From CAknView +// Event handler for status pane size changes. +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::HandleStatusPaneSizeChange() + { + if ( iContainer && !iSwitchingView ) + { + TUid activeView = iViewUtility->ActiveViewImplementationUid(); + if ( KMPXEqualizerViewImplementationId == activeView ) + { + iContainer->AdjustOrdinalPosition( KMPXPlaybackViewWindowBackground ); + } + else + { + iContainer->SetRect( ClientRect() ); + iContainer->DrawDeferred(); + } + } + } + +// --------------------------------------------------------------------------- +// From CAknView +// Handles a view activation. +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::DoActivateL( + const TVwsViewId& aPrevViewId, + TUid /* aCustomMessageId */, + const TDesC8& /* aCustomMessage */ ) + { + MPX_FUNC_EX( "CMPXCommonPlaybackViewImp::DoActivateL()" ); + + iSwitchingView = EFalse; + iDatabaseNotReady = EFalse; + iUnsupportedNoteDisabled = EFalse; + delete iOldUri; + iOldUri = NULL; + CAknToolbar* toolbar = Toolbar(); + if ( toolbar ) + { + AppUi()->AddToStackL(toolbar, + ECoeStackPriorityCba, + ECoeStackFlagRefusesFocus + | ECoeStackFlagRefusesAllKeys ); + toolbar->MakeVisible( ETrue ); + toolbar->HideItemsAndDrawOnlyBackground(EFalse); + toolbar->SetToolbarVisibility(ETrue); + } + PrepareStatusPaneForPlaybackViewL(); + + iRandomMode = KErrNotFound; + iRepeatMode = KErrNotFound; + + iBacking = EFalse; + // Update view + // use idle call back since extracting album art binary data is slow + if ( iIdle ) + { + if ( iIdle->IsActive() ) + { + MPX_DEBUG1( "CMPXCommonPlaybackViewImp::DoActivateL() iIdle active, canceling" ); + iIdle->Cancel(); + } + delete iIdle; + iIdle = NULL; + } + iIdle = CIdle::NewL( CActive::EPriorityIdle ); + iIdle->Start( TCallBack( CMPXCommonPlaybackViewImp::DeferredAlbumArtExtractCallback, this ) ); + + // Retrieve current repeat & random modes, fix for EJZU-7NZ9CD + iPlaybackUtility->PropertyL( *this, EPbPropertyRandomMode ); + iPlaybackUtility->PropertyL( *this, EPbPropertyRepeatMode ); + + // Set title + // Ignore errors from updating title pane since if that is not + // updated, still want to activate view + TRAP_IGNORE( UpdateTitlePaneL() ); + + if ( !AknLayoutUtils::PenEnabled() ) + { + CEikButtonGroupContainer* cba = Cba(); + if ( cba ) + { +#ifdef __ENABLE_MSK + iCommonUiHelper->SetMiddleSoftKeyLabelL( + *cba, + R_TEXT_SOFTKEY_EMPTY, + EAknSoftkeyForwardKeyEvent ); +#endif // __ENABLE_MSK + } + } + + if( aPrevViewId.iAppUid == KAppUidMusicPlayerX && iContainer ) + { + iContainer->SetTransitionType(EMPXTranstionToLeft); + // Transition was started in collection view, we end it here. + iContainer->EndTransition(); + } + + + iPlaybackState = iPlaybackUtility->StateL(); + MPX_DEBUG2("CMPXCommonPlaybackViewImp::DoActivateL(): state = %d", iPlaybackState); + if ( iPlaybackState == EPbStateInitialising ) + { + delete iMedia; + iMedia = NULL; + UpdatePlaybackStateL( iPlaybackState ); + UpdateTrackInfoL( iMedia ); + } + else + { + // reset iNewItemOpened when Playback view is activated when state is + // not initializing (e.g. user pressed Go to Now Playing view) + MPX_DEBUG1("CMPXCommonPlaybackViewImp::DoActivateL() reset iNewItemOpened"); +#ifndef CAMESE_IN_DRM_UTILITY + if (iCameseSuperDistSupport) + { + iNewItemOpened = EFalse; + } +#endif + if ( iMedia == NULL ) + { + MMPXSource* s = iPlaybackUtility->Source(); + if ( s ) + { + CMPXCollectionPlaylist* playlist( s->PlaylistL() ); + if ( playlist ) + { + CleanupStack::PushL( playlist ); + if ( playlist->Count() > 0 ) + { + RequestMediaL(); + UpdatePlaybackStateL( iPlaybackState ); + } + else + { + // playlist count is 0, no tracks + iPlaybackState = EPbStateNotInitialised; + } + CleanupStack::PopAndDestroy( playlist ); + } + else + { + // If empty playlist, then no tracks + iPlaybackState = EPbStateNotInitialised; + } + } + } + } + } + +// --------------------------------------------------------------------------- +// From CAknView +// View deactivation function. +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::DoDeactivate() + { + MPX_FUNC_EX( "CMPXCommonPlaybackViewImp::DoDeactivate()" ); + iMPXUtility->CancelRequest(); + + if ( iContainer ) + { + AppUi()->RemoveFromStack( iContainer ); + delete iContainer; + iContainer = NULL; + iBacking = ETrue; + } + // Hide the toolbar when view is deactivated. Otherwise it may interfere + // with other views (e.g. Antriksh based collection view) that doesn't have + // toolbar to not draw correctly. + CAknToolbar* toolbar = Toolbar(); + if ( toolbar ) + { + toolbar->HideItemsAndDrawOnlyBackground(ETrue); + toolbar->SetToolbarVisibility(EFalse); + toolbar->MakeVisible(EFalse); + AppUi()->RemoveFromStack( toolbar ); + } + + if ( iTNRequestTimer->IsActive()) + { + iTNRequestTimer->Cancel(); + } + } + +// --------------------------------------------------------------------------- +// From CAknView +// Foreground event handling function. +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::HandleForegroundEventL( TBool aForeground ) + { + MPX_DEBUG2( "--->CMPXCommonPlaybackViewImp::HandleForegroundEventL(%d)", aForeground ); + +#ifdef BACKSTEPPING_INCLUDED + TInt statusInfo( KMPXBackSteppingNotConsumed ); + MPX_DEBUG3("CMPXCommonPlaybackViewImp::HandleForegroundEventL - is in foreground=%d, this view=0x%x", + aForeground, Id().iUid ); + if( aForeground && + iViewUtility && + ( iViewUtility->ActiveViewImplementationUid() != KNullUid ) ) + { + TInt viewId( iViewUtility->ActiveViewType().iUid ); + TBuf8 buf; + buf.Copy( KMVPrefix ); + buf.AppendNum( viewId ); + + TRAP_IGNORE( + statusInfo = + iBackSteppingUtility->ForwardActivationEventL( buf, ETrue ); + ); + MPX_DEBUG3("CMPXCommonPlaybackViewImp::HandleForegroundEventL - viewId=0x%x, statusInfo=%d", viewId, statusInfo ); + } +#endif // BACKSTEPPING_INCLUDED + + // Reset state when view's visibility is changed. + iSwitchingView = EFalse; + + CAknView::HandleForegroundEventL( aForeground ); + if ( iContainer ) + { + iContainer->HandleForegroundEventL( aForeground ); + if ( aForeground ) + { + if ( iMedia ) + { + MPX_DEBUG1( "CMPXCommonPlaybackViewImp::HandleForegroundEventL iMedia valid" ); + MMPXSource* s = iPlaybackUtility->Source(); + if ( s && iMedia->IsSupported( KMPXMediaGeneralId ) ) + { + CMPXCollectionPlaylist* playlist = s->PlaylistL(); + if ( playlist ) + { + MPX_DEBUG1( "CMPXCommonPlaybackViewImp::HandleForegroundEventL playlist valid" ); + const CMPXCollectionPath& path = playlist->Path(); + TMPXItemId id( path.Id() ); + delete playlist; + TMPXItemId cacheId( + iMedia->ValueTObjectL( KMPXMediaGeneralId ) ); + if ( id != cacheId ) + { + MPX_DEBUG1( "CMPXCommonPlaybackViewImp::HandleForegroundEventL requesting media" ); + RequestMediaL(); + } + } + } + } + + iContainer->StartMarquee( ETextTrack ); + iContainer->StartMarquee( ETextArtist ); + iContainer->DrawNow(); + } + } + + // to stop seek when music player goes to background. + if ( iContainer && !aForeground && iIsffButtonPressed ) + { + iIsffButtonPressed = EFalse; + iContainer->RestoreButtons( iPlaybackState ); + iPlaybackUtility->CommandL( EPbCmdStopSeeking ); + } + + if ( aForeground && ( iViewUtility->ActiveViewType() == TUid::Uid( KMPXPluginTypePlaybackUid )) ) + TRAP_IGNORE(UpdateTitlePaneL()); + + MPX_DEBUG1( "<---CMPXCommonPlaybackViewImp::HandleForegroundEventL()" ); + } + +// --------------------------------------------------------------------------- +// From MEikMenuObserver +// Dynamically initialises a menu pane. +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::DynInitMenuPaneL( + TInt aResourceId, + CEikMenuPane* aMenuPane ) + { + TInt usbUnblockingStatus; + RProperty::Get( KMPXViewPSUid, + KMPXUSBUnblockingPSStatus, + usbUnblockingStatus); + + switch ( aResourceId ) + { + case R_MPX_PLAYBACK_VIEW_MENU: + { + if( iErrorOccured ) + { + MPX_DEBUG2( "iErrorOccured %d" , iErrorOccured); + aMenuPane->SetItemDimmed( EMPXPbvCmdSongDetails, ETrue ); + } + + if ( iIsffButtonPressed ) + { + iIsffButtonPressed = EFalse; + iContainer->RestoreButtons( iPlaybackState ); + iPlaybackUtility->CommandL( EPbCmdStopSeeking ); + } + + aMenuPane->SetItemDimmed( EMPXPbvCmdAddToPlaylist, ETrue ); + if ( !iMedia ) + { + aMenuPane->SetItemDimmed( + EMPXPbvCmdRandom, + ETrue ); + aMenuPane->SetItemDimmed( + EMPXPbvCmdRepeat, + ETrue ); + aMenuPane->SetItemDimmed( + EMPXPbvCmdFMTransmitter, + ETrue ); + aMenuPane->SetItemDimmed( + EMPXPbvCmdUpnpPlayVia, + ETrue ); + aMenuPane->SetItemDimmed( + EMPXPbvCmdEqualizer, + ETrue ); + aMenuPane->SetItemDimmed( + EMPXPbvCmdOpenMusicSettings, + ETrue ); + aMenuPane->SetItemDimmed( + EMPXPbvCmdUseAsCascade, + ETrue ); + } + else + { + if ( KErrNotFound == iRandomMode && iEmbedded ) + { + aMenuPane->SetItemDimmed( + EMPXPbvCmdRandom, + ETrue ); + } + if ( KErrNotFound == iRepeatMode && iEmbedded ) + { + aMenuPane->SetItemDimmed( + EMPXPbvCmdRepeat, + ETrue ); + } + + TBool addToPlDimmed( ETrue ); + MMPXSource* s( iPlaybackUtility->Source() ); + if ( s ) + { + CMPXCollectionPlaylist* playlist( s->PlaylistL() ); + if ( playlist ) + { + CleanupStack::PushL( playlist ); + TInt count( playlist->Count() ); + if ( count > 0 ) + { + addToPlDimmed = EFalse; + } + CleanupStack::PopAndDestroy( playlist ); + } + } + TBool isOfflineMode( EFalse ); + TBool isFormatNotSupported( EFalse ); + if ( !isOfflineMode && iMedia ) + { + if ( iMedia->IsSupported( KMPXMediaDrmProtected ) ) + { + if ( iMedia->ValueTObjectL( KMPXMediaDrmProtected ) && + iMedia->IsSupported( KMPXMediaDrmCanSetAutomated ) ) + { + // if it's drm protected, check if + // KMPXMediaDrmCanSetAutomated + isFormatNotSupported = !( + iMedia->ValueTObjectL( KMPXMediaDrmCanSetAutomated ) ); + } + } + } + aMenuPane->SetItemDimmed( + EMPXPbvCmdUseAsCascade, + !iMedia || isFormatNotSupported || + iPlaybackState == EPbStateInitialising ); + + // if help is not enabled, do not show "help" + if ( !FeatureManager::FeatureSupported( KFeatureIdHelp ) ) + { + aMenuPane->SetItemDimmed( + EAknCmdHelp, + ETrue ); + } + + // Check if HDMI cable is connected + TBool isHDMIConnected = iTvOutConfig->HdmiCableConnected(); + aMenuPane->SetItemDimmed( EMPXPbvCmdOpenMusicSettings, isHDMIConnected ); + aMenuPane->SetItemDimmed( EMPXPbvCmdEqualizer, isHDMIConnected ); + + // Check if FM Transmitter is supported + if ( !FeatureManager::FeatureSupported( KFeatureIdFmtx ) || isHDMIConnected ) + { + aMenuPane->SetItemDimmed( + EMPXPbvCmdFMTransmitter, + ETrue ); + } + + + if ( iUpnpFrameworkSupport ) + { + if ( !iMedia || !IsUpnpVisibleL() ) + { + GetCurrentPlayerDetails(); + if ( iCurrentPlayerType == EPbLocal ) + { + aMenuPane->SetItemDimmed( + EMPXPbvCmdUpnpPlayVia, + ETrue); + } + } + } + else + { + aMenuPane->SetItemDimmed( EMPXPbvCmdUpnpPlayVia, ETrue); + } + aMenuPane->SetItemDimmed( EAknCmdExit, iExitOptionHidden ); + if (iServiceHandler->HandleSubmenuL(*aMenuPane)) + { + return; + } + } + break; + } + case R_MPX_PLAYBACK_PLAY_VIA_SUB_MENU: + { + if ( iUpnpFrameworkSupport ) + { + AddPlayersNamesToMenuL( *aMenuPane ); + } + break; + } + case R_MPX_PLAYBACK_REPEAT_SUB_MENU: + { + TInt symbolOff = EEikMenuItemSymbolIndeterminate; + TInt symbolAll = EEikMenuItemSymbolIndeterminate; + TInt symbolOne = EEikMenuItemSymbolIndeterminate; + + if ( EPbRepeatOff == iRepeatMode ) + { + symbolOff = EEikMenuItemSymbolOn; + } + else if ( EPbRepeatAll == iRepeatMode ) + { + symbolAll = EEikMenuItemSymbolOn; + } + else + { + symbolOne = EEikMenuItemSymbolOn; + } + + aMenuPane->SetItemButtonState( + EMPXPbvCmdRepeatOff, + symbolOff ); + aMenuPane->SetItemButtonState( + EMPXPbvCmdRepeatAll, + symbolAll ); + aMenuPane->SetItemButtonState( + EMPXPbvCmdRepeatOne, + symbolOne ); + break; + } + case R_MPX_PLAYBACK_RANDOM_SUB_MENU: + { + TInt symbolOff = EEikMenuItemSymbolOn; + TInt symbolOn = EEikMenuItemSymbolIndeterminate; + + if ( iRandomMode ) + { + symbolOff = EEikMenuItemSymbolIndeterminate; + symbolOn = EEikMenuItemSymbolOn; + } + + aMenuPane->SetItemButtonState( + EMPXPbvCmdRandomOn, + symbolOn ); + aMenuPane->SetItemButtonState( + EMPXPbvCmdRandomOff, + symbolOff ); + break; + } + case R_MPX_PBV_ADD_TO_PL_SUB_MENU: + { + TBool dim( ETrue ); + delete iUserPlaylists; + iUserPlaylists = NULL; + iUserPlaylists = iCommonUiHelper->FindPlaylistsL(); + if ( iUserPlaylists ) + { + const CMPXMediaArray* mediaArray = + iUserPlaylists->Value( + KMPXMediaArrayContents ); + User::LeaveIfNull(const_cast(mediaArray)); + + TInt entriesCount( mediaArray->Count() ); + MPX_DEBUG2( "CMPXCommonPlaybackViewImp::DynInitMenuPaneL Entry count = %d", entriesCount ); + if ( entriesCount > 0 ) + { + dim = EFalse; + } + } + aMenuPane->SetItemDimmed( EMPXPbvCmdAddToSavedPlaylist, dim ); + break; + } + default: + { + // Do nothing + break; + } + } + if ( iServiceHandler->IsAiwMenu(aResourceId)) + { + MPX_DEBUG1( "CMPXCollectionViewImp::DynInitMenuPaneL(): Aiw menu for assign" ); + CAiwGenericParamList& paramList = iServiceHandler->InParamListL(); + FillAiwParametersL(paramList, EFalse); + iServiceHandler->InitializeMenuPaneL(*aMenuPane, + aResourceId, + EMPXPbvCmdAiwCmdAssign, + paramList); + MPX_DEBUG1( "CMPXCollectionViewImp::DynInitMenuPaneL(): Aiw menu for assign end" ); + } + } + +// --------------------------------------------------------------------------- +// From MMPXLayoutSwitchObserver +// Callback function when layout is changed. +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::HandleLayoutChange() + { + if (iContainer && !iSwitchingView) + { + if ( !Layout_Meta_Data::IsLandscapeOrientation() ) + { + TUid activeView = iViewUtility->ActiveViewImplementationUid(); + + // only switch to flat if current view is not equalizer + // since it'll mess up equilizer's screen + if ( StatusPane()->CurrentLayoutResId() != + R_AVKON_STATUS_PANE_LAYOUT_USUAL_FLAT && + activeView != KMPXEqualizerViewImplementationId && + activeView != KMPXMetadataEditorDialogImplementationId ) + { + TRAP_IGNORE( + StatusPane()->SwitchLayoutL( R_AVKON_STATUS_PANE_LAYOUT_USUAL_FLAT )); + } + } + else + { + if ( StatusPane()->CurrentLayoutResId() != + R_AVKON_WIDESCREEN_PANE_LAYOUT_USUAL_FLAT ) + { + TRAP_IGNORE( + StatusPane()->SwitchLayoutL( R_AVKON_WIDESCREEN_PANE_LAYOUT_USUAL_FLAT )); + } + } + + iContainer->SetRect( ClientRect() ); + iContainer->DrawDeferred(); + } + } + +// --------------------------------------------------------------------------- +// From MCoeViewDeactivationObserver +// Handles the activation of the view aNewlyActivatedViewId before +// the old view aViewIdToBeDeactivated is to be deactivated. +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::HandleViewActivation( + const TVwsViewId& aNewlyActivatedViewId, + const TVwsViewId& aViewIdToBeDeactivated ) + { + MPX_FUNC_EX( "CMPXCommonPlaybackViewImp::HandleViewActivation AV" ); + // Check if this view is going to be deactivated + if ( aViewIdToBeDeactivated.iViewUid == Id() ) + { + if ( aNewlyActivatedViewId.iViewUid != Id() ) + { + iSwitchingView = ETrue; + } + } + + if ( iPBViewToBeActivated ) + { + iLastPBViewActivated = ( aNewlyActivatedViewId.iViewUid == Id() ); + MPX_DEBUG2( "CMPXCommonPlaybackViewImp::HandleViewActivation iLastPBViewActivated %d", iLastPBViewActivated ); + } + } + +// --------------------------------------------------------------------------- +// From MMPXViewActivationObserver +// Handle view activation. +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::HandleViewActivation( + const TUid& aCurrentViewType, + const TUid& /*aPreviousViewType*/ ) + { + MPX_FUNC_EX( "CMPXCommonPlaybackViewImp::HandleViewActivation VF" ); + iPBViewToBeActivated = ( KMPXPluginTypePlaybackUid == aCurrentViewType.iUid ); + if(iPBViewToBeActivated) + { + HandleLayoutChange(); + } + MPX_DEBUG2( "CMPXCommonPlaybackViewImp::HandleViewActivation iPBViewToBeActivated %d", iPBViewToBeActivated ); + } +// --------------------------------------------------------------------------- +// From MMPXViewActivationObserver +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::HandleViewUpdate( + TUid /* aViewUid */, + MMPXViewActivationObserver::TViewUpdateEvent /* aUpdateEvent */, + TBool /* aLoaded */, + TInt /* aData */) + { + // Do nothing, this should be handled by the AppUI + } + +// --------------------------------------------------------------------------- +// From MMPXPSKeyObserver +// Handle PS event +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::HandlePSEvent( + TUid aUid, + TInt aKey ) + { + MPX_DEBUG2( "CMPXCommonPlaybackViewImp::HandlePSEvent %d", aKey ); + + if ( aUid == KPSUidHWRMFmTx && aKey == KHWRMFmTxStatus ) + { + // only responds to FM TX key value change + TRAP_IGNORE( UpdateFMTransmitterInfoL() ); + } + } + +// --------------------------------------------------------------------------- +// From MMPXCenRepObserver +// Handle PS event +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::HandleSettingChange( + const TUid& aRepositoryUid, + TUint32 aSettingId ) + { + MPX_DEBUG2( "CMPXCommonPlaybackViewImp::HandleSettingChange %d", aSettingId ); + + if ( aRepositoryUid == KCRUidFmTxCenRes && + aSettingId == KFmTxCenResKeyFrequency ) + { + // only responds to FM Tx Frequency value change + TRAP_IGNORE( UpdateFMTransmitterInfoL() ); + } + } + +// ----------------------------------------------------------------------------- +// CMPXCommonPlaybackViewImp::IsUpnpVisible +// Taken from Gallery upnp support implementation +// ----------------------------------------------------------------------------- +// +EXPORT_C TBool CMPXCommonPlaybackViewImp::IsUpnpVisibleL() + { + MPX_FUNC( "CMPXCommonPlaybackViewImp::IsUpnpVisible" ); + TBool returnValue = EFalse; + +#ifdef UPNP_INCLUDED + if ( iUpnpCopyCommand && iUpnpFrameworkSupport ) + { + returnValue = iUpnpCopyCommand->IsAvailableL(); + } +#endif + return returnValue; + + } + +// ----------------------------------------------------------------------------- +// CMPXCommonPlaybackViewImp::AddPlayersNamesToMenuL +// Add all available players names to the Play via submenu +// ----------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::AddPlayersNamesToMenuL( + CEikMenuPane& aMenuPane ) + { + if ( iUpnpFrameworkSupport ) + { + RArray playerTypes; + CleanupClosePushL(playerTypes); + + MMPXPlayerManager& manager = iPlaybackUtility->PlayerManager(); + manager.GetPlayerTypesL(playerTypes); + + GetCurrentPlayerDetails(); + + TInt countPlayersTypes( playerTypes.Count() ); + TInt countLocalType( 0 ); + TInt countRemoteType( 0 ); + + if ( countPlayersTypes >= 1 ) + { + iPlayersList.Close(); + + for ( TInt i = 0; i < countPlayersTypes; i++) + { + MPX_DEBUG3( "playerTypes[%d]: %d", i, playerTypes[i] ); + switch (playerTypes[i]) + { + case EPbLocal: + { + // we only show 1 specific type once in the menu + if ( countLocalType == 0 ) + { + AddPlayerNameToMenuL( aMenuPane, + EMPXPbvCmdUpnpPlayViaLocal, + manager, + playerTypes[i] ); + + countLocalType++; + } + break; + } + case EPbRemote: + { + // we only show 1 specific type once in the menu + if ( countRemoteType == 0 ) + { + AddPlayerNameToMenuL( aMenuPane, + EMPXPbvCmdUpnpPlayViaRemotePlayer, + manager, + playerTypes[i] ); + countRemoteType++; + } + break; + } + default: + { + // default case is handled in the next loop, we want + // to add any "other" player at the end of the list + break; + } + } + } // for loop + + for ( TInt i = 0; i < countPlayersTypes; i++) + { + MPX_DEBUG3( "playerTypes[%d]: %d", i, playerTypes[i] ); + // EPbLocal and EPbRemote were already added to the + // submenu in the previous loop + if ( playerTypes[i] != EPbLocal && + playerTypes[i] != EPbRemote ) + { + // EPbUnknown or else + TBool alreadyInTheList( EFalse ); + + for ( TInt j = 0; j < i; j++) + { + // if the new playertype is already in the list + if ( playerTypes[i] == playerTypes[j] ) + { + alreadyInTheList = ETrue; + break; + } + } + + if ( !alreadyInTheList ) + { + HBufC* buf = manager.PlayerTypeDisplayNameL(playerTypes[i]); + + if ( buf ) + { + CleanupStack::PushL(buf); + AddPlayerNameToMenuL( aMenuPane, + EMPXPbvCmdUpnpPlayViaRemotePlayer, + manager, + playerTypes[i], + *buf ); + CleanupStack::PopAndDestroy(buf); + } + // else we don't do anything. other player type is not + // currently supported. Implementation will be finalized + // when the requirement is defined. + } + } + } + } + + CleanupStack::PopAndDestroy(&playerTypes); + + if ( iPlayersList.Count() <= 1 ) + { + aMenuPane.SetItemDimmed( EMPXPbvCmdUpnpPlayViaRemotePlayer, + ETrue ); + } + } + else + { + // Remove compilation warnings + (void)aMenuPane; + } + } + +// ----------------------------------------------------------------------------- +// CMPXCommonPlaybackViewImp::AddPlayerNameToMenuL +// Add 1 player name to the submenu +// ----------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::AddPlayerNameToMenuL( + CEikMenuPane& aMenuPane, + TInt aCommandId, + MMPXPlayerManager& aPlayerManager, + TMPXPlaybackPlayerType& aPlayerType, + const TDesC& aMenuText ) + { + if ( iUpnpFrameworkSupport ) + { + RArray players; + CleanupClosePushL(players); + aPlayerManager.GetPlayerListL(players, aPlayerType); + + // For now we only keep the first player we find + // Local player is always the first one in the list + // Ui spec limitation + MPX_DEBUG2( "players[0]: %d", players[0].iUid ); + if ( aCommandId == EMPXPbvCmdUpnpPlayViaLocal ) + { + iPlayersList.Insert(players[0], 0); + } + else if ( ( aCommandId == EMPXPbvCmdUpnpPlayViaRemotePlayer ) && + (iPlayersList.Count() > 1) ) + { + iPlayersList.Insert(players[0], 1); + } + else + { + iPlayersList.AppendL(players[0]); + } + CleanupStack::PopAndDestroy(&players); + + // if the player is of unknown type + if ( ( aCommandId != EMPXPbvCmdUpnpPlayViaRemotePlayer ) && + ( aCommandId != EMPXPbvCmdUpnpPlayViaLocal ) ) + { + CEikMenuPaneItem::SData menuItem; + menuItem.iText.Copy( aMenuText ); + menuItem.iCascadeId = 0; + menuItem.iFlags = EEikMenuItemRadioEnd; + + menuItem.iCommandId = aCommandId + (iPlayersList.Count() - 1); + aCommandId = menuItem.iCommandId; + + aMenuPane.AddMenuItemL( menuItem ); + } + + if ( iCurrentPlayerType == aPlayerType ) + { + aMenuPane.SetItemButtonState( aCommandId, EEikMenuItemSymbolOn ); + } + } + else + { + // Remove compilation warnings + (void)aMenuPane; + (void)aCommandId; + (void)aPlayerManager; + (void)aPlayerType; + (void)aMenuText; + } + } + +// ----------------------------------------------------------------------------- +// CMPXCommonPlaybackViewImp::GetCurrentPlayerDetails +// Retrieves the current player name and type +// ----------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::GetCurrentPlayerDetails() + { + if ( iUpnpFrameworkSupport ) + { + + MMPXPlayerManager& manager = iPlaybackUtility->PlayerManager(); + TUid currentlyUsedPlayer; + TInt currentlyUsedSubPlayer; + iCurrentPlayerType = EPbLocal; + delete iSubPlayerName; + iSubPlayerName = NULL; + + TRAP_IGNORE( manager.GetSelectionL( iCurrentPlayerType, + currentlyUsedPlayer, + currentlyUsedSubPlayer, + iSubPlayerName) ); + } + } + +// ----------------------------------------------------------------------------- +// CMPXCommonPlaybackViewImp::SelectNewPlayerL +// Selects a new player for audio playback +// ----------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::SelectNewPlayerL( + TInt aCommand ) + { + if ( iUpnpFrameworkSupport ) + { + MPX_FUNC_EX( "CMPXPlaybackViewImp::SelectNewPlayerL()" ); + MPX_DEBUG2( "CMPXPlaybackViewImp::SelectNewPlayerL(%d)", aCommand ); + + TInt errorSelectPlayer( KErrCancel ); + + MMPXSource* source = iPlaybackUtility->Source(); + CMPXCollectionPlaylist* playlist = NULL; + if ( source ) + { + playlist = source->PlaylistL(); + if ( playlist ) + { + CleanupStack::PushL( playlist ); + iPlaybackUtility->CommandL(EPbCmdPreserveState); + } + } + + switch (aCommand) + { + case EMPXPbvCmdUpnpPlayViaLocal: + { + // if Local is not already the current player, select it + if ( iCurrentPlayerType != EPbLocal ) + { + MMPXPlayerManager& manager = iPlaybackUtility->PlayerManager(); + MPX_TRAP( errorSelectPlayer, manager.ClearSelectPlayersL() ); + } + break; + } + default: + { + if ( aCommand >= EMPXPbvCmdUpnpPlayViaRemotePlayer ) + { + HBufC* buf = HBufC::NewLC( KMaxUidName ); + buf->Des().AppendNum( + (iPlayersList[aCommand - + EMPXPbvCmdUpnpPlayViaLocal]).iUid ); + + // ActivateViewL leaves with KErrCancel if the dialog is + // cancelled + // ActivateViewL leaves with KErrInUse if the selected player + // is already the active player + MPX_TRAP(errorSelectPlayer, iViewUtility->ActivateViewL( + TUid::Uid( KMPXPluginTypeUPnPBrowseDialogUid ), + buf )); + CleanupStack::PopAndDestroy( buf ); + } + break; + } + } + + // A new player was successfully selected, playback view changes + if ( errorSelectPlayer == KErrNone ) + { + if ( playlist ) + { + iViewUtility->PushDefaultHistoryL(); + iPlaybackUtility->InitL( *playlist, ETrue ); + } + } + + if (playlist) + { + CleanupStack::PopAndDestroy( playlist ); + } + } + else + { + // Remove compilation warnings + (void)aCommand; + } + } + +// ----------------------------------------------------------------------------- +// CMPXCommonPlaybackViewImp::AddToSavedPlaylistL +// Adds current item to a saved playlist +// ----------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::AddToSavedPlaylistL() + { + MPX_DEBUG1("CMPXPlaybackViewImp::AddToSavedPlaylistL(): entering"); + + ASSERT( iMedia ); + if ( !iUserPlaylists ) + { + iUserPlaylists = iCommonUiHelper->FindPlaylistsL(); + } + + CMPXMedia* media = PrepareMediaForPlaylistLC( *iMedia ); + MPX_TRAPD( err, iCommonUiHelper->AddToSavedPlaylistL( + *iUserPlaylists, + *media, + this, + this ) ); + CleanupStack::PopAndDestroy( media ); + if ( KErrNone != err ) + { + HandleErrorL( err ); + } + delete iUserPlaylists; + iUserPlaylists = NULL; + + MPX_DEBUG1("CMPXPlaybackViewImp::AddToSavedPlaylistL(): exiting"); + } + +// ----------------------------------------------------------------------------- +// CMPXCommonPlaybackViewImp::AddToNewPlaylistL +// Adds current item to a new playlist +// ----------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::AddToNewPlaylistL() + { + MPX_DEBUG1("CMPXPlaybackViewImp::AddToNewPlaylistL(): entering"); + + if ( iMedia ) + { + CMPXMedia* media( PrepareMediaForPlaylistLC( *iMedia )); + iCommonUiHelper->CreatePlaylistL( + *media, + this, + this ); + CleanupStack::PopAndDestroy( media ); + } + delete iUserPlaylists; + iUserPlaylists = NULL; + + MPX_DEBUG1("CMPXPlaybackViewImp::AddToNewPlaylistL(): exiting"); + } + +// --------------------------------------------------------------------------- +// PrepareMediaForPlaylistLC +// Prepares media for adding to a playlist +// --------------------------------------------------------------------------- +// +EXPORT_C CMPXMedia* CMPXCommonPlaybackViewImp::PrepareMediaForPlaylistLC( + const CMPXMedia& aMedia ) + { + MPX_DEBUG1("CMPXPlaybackViewImp::PrepareMediaForPlaylistLC() entering"); + + CMPXMedia* media = CMPXMedia::NewL(); + CleanupStack::PushL( media ); + CMPXMediaArray* mediaArray = CMPXMediaArray::NewL(); + CleanupStack::PushL( mediaArray ); + CMPXMedia* entry = CMPXMedia::NewL( aMedia ); + CleanupStack::PushL( entry ); + mediaArray->AppendL( entry ); + CleanupStack::Pop( entry ); + media->SetCObjectValueL( + KMPXMediaArrayContents, + mediaArray ); + media->SetTObjectValueL( + KMPXMediaArrayCount, + mediaArray->Count() ); + CleanupStack::PopAndDestroy( mediaArray ); + MPX_DEBUG1("CMPXPlaybackViewImp::PrepareMediaForPlaylistLC() exiting"); + return media; + } + +// ----------------------------------------------------------------------------- +// CMPXCommonPlaybackViewImp::IsCommandSupportedL +// Check if the command is supported by the remote player +// ----------------------------------------------------------------------------- +// +EXPORT_C TBool CMPXCommonPlaybackViewImp::IsCommandSupportedL() + { + TBool forwardCommand = ETrue; + if ( iUpnpFrameworkSupport && IsUpnpVisibleL() ) + { + // retrieve iCurrentPlayerType info + GetCurrentPlayerDetails(); + + if ( iCurrentPlayerType != EPbLocal) + { + // show error note, only in first key press + if( !iUnsupportedNoteDisabled ) + { + iUnsupportedNoteDisabled = ETrue; + iOldPosition = iPosition; + if( iContainer && iIsTapped ) + { + iContainer->SetNewSongPosition( iPosition * KMPXOneSecInMilliSecs ); + } + HBufC* dialogText = NULL; + TBool setText = EFalse; + switch ( iCommandSender ) + { + case ECsMediaKey: + { + dialogText = StringLoader::LoadLC( R_MPX_MEDIA_KEYS_NOT_SUPPORTED ); + setText = ETrue; + break; + } + case ECsRenderer: + { + dialogText = StringLoader::LoadLC( R_MPX_REQUEST_REJECTED ); + setText = ETrue; + break; + } + default: + { + break; + } + } + + if( setText ) + { + CAknErrorNote* errNote = new(ELeave) CAknErrorNote(ETrue); + errNote->SetTimeout(CAknNoteDialog::ELongTimeout); + errNote->ExecuteLD( *dialogText ); + CleanupStack::PopAndDestroy( dialogText ); + forwardCommand = EFalse; + } + } + } + } + return forwardCommand; + } + +// --------------------------------------------------------------------------- +// From MProgressDialogCallback +// Callback method. Get's called when a dialog is dismissed +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::DialogDismissedL( TInt aButtonId ) + { + MPX_DEBUG2("--->CMPXCommonPlaybackViewImp::DialogDismissedL(%d)", aButtonId); + switch (aButtonId) + { + case EAknSoftkeyCancel: + case EAknSoftkeyDone: + { + break; + } + default: + { + break; + } + } + MPX_DEBUG1("<---CMPXCommonPlaybackViewImp::DialogDismissedL()"); + } + +// --------------------------------------------------------------------------- +// From MMPXCHelperObserver +// Callback method. Get's called when a dialog is dismissed +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::HandleOperationCompleteL( TCHelperOperation /*aOperation*/, + TInt aError, + void* aArgument ) + { + MPX_DEBUG2("CMPXPlaybackViewImp::HandleAddCompletedL(%d) entering", aError); + + CMPXMedia* playlist = (CMPXMedia*) aArgument; + CleanupStack::PushL( playlist ); + + iCommonUiHelper->DismissWaitNoteL(); + if ( KErrNone == aError ) + { + const TDesC& title( playlist->ValueText( KMPXMediaGeneralTitle ) ); + HBufC* confirmTxt( StringLoader::LoadLC( + R_MPX_QTN_MUS_NOTE_TRACK_ADDED_TO_PL, + title )); + CAknConfirmationNote* note = new ( ELeave ) CAknConfirmationNote(); + + TMPlayerSecondaryDisplayNote noteId( EMPlayerNoteAddSongToPlaylist ); + note->PublishDialogL( + noteId, + KMPlayerNoteCategory ); + CAknMediatorFacade* covercl( AknMediatorFacade( note ) ); + if ( covercl ) + { + covercl->BufStream() << title; + } + + note->ExecuteLD( *confirmTxt ); + CleanupStack::PopAndDestroy( confirmTxt ); + } + else + { + HandleErrorL( aError ); + } + CleanupStack::PopAndDestroy( playlist ); + MPX_DEBUG1("CMPXPlaybackViewImp::HandleAddCompletedL() exiting"); + } + +// ----------------------------------------------------------------------------- +// From MMPXCollectionObserver +// ----------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::HandleCollectionMessage(CMPXMessage* aMsg, + TInt aErr ) + { + TRAP_IGNORE( DoHandleCollectionMessageL( aMsg, aErr ) ); + } + +// ----------------------------------------------------------------------------- +// From MMPXCollectionObserver +// ----------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::HandleOpenL(const CMPXMedia& /*aEntries*/, TInt /*aIndex*/, + TBool /*aComplete*/, TInt /*aError*/) + { + // Do Nothing + } + +// ----------------------------------------------------------------------------- +// From MMPXCollectionObserver +// ----------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::HandleOpenL(const CMPXCollectionPlaylist& /*aPlaylist*/, + TInt /*aError*/) + { + // Do Nothing + } + +// ----------------------------------------------------------------------------- +// From MMPXCollectionObserver +// ----------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::HandleCommandComplete(CMPXCommand* /*aCommandResult*/, + TInt /*aError*/) + { + // Do Nothing + } + +// ---------------------------------------------------------------------------- +// void CMPXCommonPlaybackViewImp::DeferredAlbumArtExtractCallback +// call back function for deferred view updates. +// ---------------------------------------------------------------------------- +// +TInt CMPXCommonPlaybackViewImp::DeferredAlbumArtExtractCallback( TAny* aPtr ) + { + MPX_FUNC( "CMPXCommonPlaybackViewImp::DeferredAlbumArtExtractCallback" ); + CMPXCommonPlaybackViewImp* self = + static_cast( aPtr ); + TRAP_IGNORE( self->UpdateViewL() ); + return KErrNone; + } + +//---------------------------------------------------------------------------- +// CMPXCommonPlaybackViewImp::DelayedExit +// call back function for delayed view deactivation +//---------------------------------------------------------------------------- +// +TInt CMPXCommonPlaybackViewImp::DelayedExit( TAny* aPtr ) + { + MPX_FUNC( "CMPXCommonPlaybackViewImp::DelayedExit" ); + CMPXCommonPlaybackViewImp* self = + static_cast( aPtr ); + TRAP_IGNORE( self->HandleCommandL(EAknSoftkeyBack) ); + return KErrNone; + } + +// --------------------------------------------------------------------------- +// Handle playback error message. +// --------------------------------------------------------------------------- +// +void CMPXCommonPlaybackViewImp::DoHandleErrorPlaybackMessageL( TInt aError ) + { + MPX_DEBUG2( "CMPXCommonPlaybackViewImp::DoHandleErrorPlaybackMessage(): Handle the error %d", aError); + + // Request media to handle error. We need to do that in + // order to request DRM details. + iDelayedError = aError; + RequestMediaL( ETrue ); + } + +// --------------------------------------------------------------------------- +// Handle collection message +// --------------------------------------------------------------------------- +// +void CMPXCommonPlaybackViewImp::DoHandleCollectionMessageL( + CMPXMessage* aMsg, TInt /*aErr*/ ) + { + MPX_FUNC_EX( "CMPXCommonPlaybackViewImp::DoHandleCollectionMessageL" ); + if( aMsg ) + { + TMPXMessageId id( aMsg->ValueTObjectL( KMPXMessageGeneralId ) ); + if ( KMPXMessageGeneral == id ) + { + TInt event( aMsg->ValueTObjectL( KMPXMessageGeneralEvent ) ); + TInt op( aMsg->ValueTObjectL( KMPXMessageGeneralType ) ); + TInt data( aMsg->ValueTObjectL( KMPXMessageGeneralData ) ); + + if( event == TMPXCollectionMessage::EBroadcastEvent && + op == EMcMsgDiskRemoved && + iContainer && + iViewUtility->ActiveViewType() != TUid::Uid(KMPXPluginTypeWaitNoteDialogUid) ) + { + TRAP_IGNORE( AknDialogShutter::ShutDialogsL( *CEikonEnv::Static() ) ); + StopDisplayingMenuBar(); + TRAP_IGNORE( UpdateTitlePaneL() ); // some dialogs change the title. ie equalizer + } + else if( event == TMPXCollectionMessage::EBroadcastEvent ) + { + if( op == EMcMsgUSBMassStorageStart || + op == EMcMsgUSBMTPStart || + op == EMcMsgFormatStart ) + { + iDatabaseNotReady = ETrue; + } + else if( op == EMcMsgUSBMassStorageEnd || + op == EMcMsgUSBMTPEnd || + op == EMcMsgFormatEnd ) + { + iDatabaseNotReady = EFalse; + } + else if( op == EMcMsgDiskInserted ) + { + // Need to reset the prev/next buttons state if they are pressed at the moment. + if (iSkipBtnPressed) + { + if ( AknLayoutUtils::PenEnabled() ) + { + if ( Toolbar() ) + { + CAknToolbar* toolbar = Toolbar(); + CAknButton* skipControl; + skipControl = (CAknButton*)(toolbar->ComponentControl( 0 )); + skipControl->ResetState(); + skipControl->DrawNow(); + + skipControl = (CAknButton*)(toolbar->ComponentControl( 2 )); + skipControl->ResetState(); + skipControl->DrawNow(); + } + } + iSkipBtnPressed = EFalse; + } + } + } + else if (event == TMPXCollectionMessage::EPathChanged && + op == EMcPathChangedByOpen && + data == EMcItemOpened) + { // Open new entries + MPX_DEBUG1("CMPXPlaybackViewImp::HandleCollectionMessage() New Item Opened"); + iNewItemOpened = ETrue; + delete iMedia; + iMedia = NULL; + } + } + } + } + +// ----------------------------------------------------------------------------- +// CMPXCommonPlaybackViewImp::FillAiwParameters +// ----------------------------------------------------------------------------- +// +void CMPXCommonPlaybackViewImp::FillAiwParametersL( + CAiwGenericParamList& aParamList, TBool aSaved ) + { + TFileName location(NULL); + if ( aSaved ) + { + location = MPXTlsHelper::FilePath(); + } + + if ( !location.Length()) + { + location = iMedia->ValueText( KMPXMediaGeneralUri ); + } + + MPX_DEBUG1( "Todd CMPXCommonPlaybackViewImp::FillAiwParametersL location=" ); + #ifdef _DEBUG + RDebug::RawPrint(location); + #endif + + TPtrC mimeType(iMedia->ValueText( KMPXMediaGeneralMimeType )); + MPX_DEBUG1( "Todd CMPXCommonPlaybackViewImp::FillAiwParametersL mime=" ); + #ifdef _DEBUG + RDebug::RawPrint(mimeType); + #endif + TAiwVariant varMime(mimeType); + if ( !mimeType.Length() && ( iMediaRecognizer ) ) + { + varMime.Set(iMediaRecognizer->MimeTypeL(location)); + } + TAiwGenericParam paramMime(EGenericParamMIMEType, varMime); + aParamList.Reset(); + aParamList.AppendL(paramMime); + TAiwVariant varFile(location); + TAiwGenericParam paramFile(EGenericParamFile, varFile); + aParamList.AppendL(paramFile); + } + +// --------------------------------------------------------------------------- +// Updates the middle softkey display +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::UpdateMiddleSoftKeyDisplayL() + { + MPX_FUNC("CMPXCommonPlaybackViewImp::UpdateMiddleSoftKeyDisplayL"); + + if (iContainer && !AknLayoutUtils::PenEnabled() ) + { + CEikButtonGroupContainer* cba = Cba(); + if (cba) + { + MMPXSource* s = iPlaybackUtility->Source(); + if ( s ) + { + CMPXCollectionPlaylist* playlist = s->PlaylistL(); + if ( playlist ) + { + CleanupStack::PushL( playlist ); + if ( playlist->Count() > 0 ) + { + TMPXPlaybackState state = iPlaybackUtility->StateL(); + + if ((state == EPbStateInitialising) ||(state == EPbStatePlaying)) + { + iCommonUiHelper->SetMiddleSoftKeyLabelL( *cba, R_QTN_MSK_PAUSE, EAknSoftkeyForwardKeyEvent); + } + else + { + iCommonUiHelper->SetMiddleSoftKeyLabelL( *cba, R_QTN_MSK_PLAY, EAknSoftkeyForwardKeyEvent); + } + } + CleanupStack::PopAndDestroy( playlist ); + } + } + MPX_DEBUG1("CMPXCommonPlaybackViewImp::UpdateMiddleSoftKeyDisplayL - new label displayed"); + + cba->DrawDeferred(); + } + } + } + +// --------------------------------------------------------------------------- +// Updates the middle toolbar button +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::UpdateToolbarL() + { + MPX_FUNC("CMPXCommonPlaybackViewImp::UpdateToolbarL"); + + if ( AknLayoutUtils::PenEnabled() ) + { + if ( Toolbar() ) + { + CAknToolbar* toolbar = Toolbar(); + toolbar->SetDimmed( EFalse ); + CAknButton* rwControl; + rwControl = (CAknButton*)(toolbar->ComponentControl( 0 )); + CAknButton* pausePlayControl; + pausePlayControl = (CAknButton*)(toolbar->ComponentControl( 1 )); + CAknButton* fwControl; + fwControl = (CAknButton*)(toolbar->ComponentControl( 2 )); + MMPXSource* s = iPlaybackUtility->Source(); + if ( s ) + { + CMPXCollectionPlaylist* playlist = s->PlaylistL(); + if ( playlist ) + { + CleanupStack::PushL( playlist ); + if ( playlist->Count() > 0 ) + { + if( pausePlayControl ) + { + TMPXPlaybackState state = iPlaybackUtility->StateL(); + if ( state == EPbStatePlaying ) + { + pausePlayControl->SetCurrentState(0, ETrue); + } + //get EPbStateInitialising when skipping to next, ignore it to remove play/pause key flicker + //It is showing the state that was previously shown when EPbStateInitializing + else if ( state != EPbStateInitialising ) + { + pausePlayControl->SetCurrentState(1, ETrue); + } + } + + if( rwControl && fwControl ) + { + rwControl->SetDimmed( EFalse ); + rwControl->DrawNow(); + fwControl->SetDimmed( EFalse ); + fwControl->DrawNow(); + } + } + + CleanupStack::PopAndDestroy( playlist ); + } + else + { + if( pausePlayControl ) + { + TMPXPlaybackState state = iPlaybackUtility->StateL(); + if ( ( state == EPbStateInitialising ) || + ( state == EPbStatePlaying ) ) + { + pausePlayControl->SetCurrentState( 0, ETrue ); + } + else + { + pausePlayControl->SetCurrentState( 1, ETrue ); + } + } + } + } + else + { + toolbar->SetDimmed( ETrue ); + } + } + } + } +// ---------------------------------------------------------------------------- +// Callback function of timer to handle delayed error +// ---------------------------------------------------------------------------- +// +TInt CMPXCommonPlaybackViewImp::HandleDelayedError( TAny* aPtr ) + { + TInt ret( KErrNone ); + TInt index( KErrNotFound ); + CMPXCommonPlaybackViewImp* pv = reinterpret_cast( aPtr ); + pv->iDelayedErrorTimer->Cancel(); + // compare index + if ( pv->iPlaybackUtility ) + { + MMPXSource* source( pv->iPlaybackUtility->Source() ); + if ( source ) + { + CMPXCollectionPlaylist* pl( NULL ); + MPX_TRAP( ret, pl = source->PlaylistL() ); + if( ret != KErrNone ) + { + return ret; + } + if ( pl ) + { + index = pl->Index(); + } + if ( pv->iErrIndex == index ) + { + MPX_TRAP( ret, pv->HandleErrorL( pv->iLastDelayedErr ) ); + } + + delete pl; + pl = NULL; + + } + } + + return ret; + } + +// --------------------------------------------------------------------------- +// Updates track's album art. +// --------------------------------------------------------------------------- +// +TInt CMPXCommonPlaybackViewImp::HandleTNRequestForCustomSizeL( TAny* aPtr ) + { + MPX_DEBUG1("CMPXCommonPlaybackViewImp::HandleTNRequestForCustomSizeL()"); + + ASSERT( aPtr ); + CMPXCommonPlaybackViewImp* pv = reinterpret_cast( aPtr ); + + ASSERT( pv->iOldUri ); + if ( pv->iContainer && !pv->iSwitchingView ) + { + TInt err( KErrNone ); + if ( pv->iMedia && pv->iMedia->IsSupported(KMPXMediaGeneralUri) ) + { + const TDesC& album = pv->iMedia->ValueText( KMPXMediaGeneralUri ); + + if ( pv->iOldUri->Compare( album ) == 0 ) + { + TRect albumArtRect( + pv->iLayout->IndicatorLayout( + pv->ClientRect(), EAlbumArtArea ) ); + + // Request for custom TN size + MPX_TRAP( err, + pv->iMPXUtility->ExtractAlbumArtL( + *pv->iMedia, + *pv->iContainer, + albumArtRect.Size(), + EFalse ); ); + } + } + + if ( KErrNone != err ) + { + // If error, show default album art + MPX_DEBUG2("CMPXCommonPlaybackViewImp::HandleTNRequestForCustomSizeL(): err = %d", err); + pv->iContainer->ExtractAlbumArtCompleted( NULL, KErrNone ); + } + } + + // cancel timer + if ( pv->iTNRequestTimer->IsActive()) + { + pv->iTNRequestTimer->Cancel(); + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// Launch Metadata Dialog to show the file details +// --------------------------------------------------------------------------- +// +EXPORT_C void CMPXCommonPlaybackViewImp::LaunchFileDetailsDialogL() + { + MPX_FUNC("CMPXCommonPlaybackViewImp::LaunchFileDetailsDialogL"); + + // Activate Metadata dialog via View Framework + CAknToolbar* toolbar = Toolbar(); + if ( toolbar ) + { + toolbar->SetToolbarVisibility(EFalse); + } + TRAP_IGNORE( iViewUtility->ActivateViewL( TUid::Uid(KMPXPluginTypeMetadataEditorUid) ) ); + if ( toolbar ) + { + toolbar->SetToolbarVisibility(ETrue); + } + iContainer->SetRect( ClientRect()); + iContainer->DrawDeferred(); + } + +// End of File