diff -r 000000000000 -r ff3acec5bc43 mpxplugins/viewplugins/views/pdplaybackview/src/mpxpdplaybackviewimp.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mpxplugins/viewplugins/views/pdplaybackview/src/mpxpdplaybackviewimp.cpp Thu Dec 17 08:45:05 2009 +0200 @@ -0,0 +1,784 @@ +/* +* 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 Progressive Download 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 + +#include "mpxcommonuihelper.h" +#include "mpxcommonplaybackview.hrh" +#include "mpxpdplaybackview.hrh" +#include "mpxpdplaybackviewimp.h" +#include "mpxpdplaybackviewcontainer.h" +#include "mpxpdplaybackviewlayout.h" +#include "mpxlog.h" + +#include +#include +#include +// CONSTANTS +_LIT( KMPXPdPlaybackRscPath, "mpxpdplaybackview.rsc" ); + + +// ======== MEMBER FUNCTIONS ======== + +// --------------------------------------------------------------------------- +// C++ default constructor can NOT contain any code, that +// might leave. +// --------------------------------------------------------------------------- +// +CMPXPdPlaybackViewImp::CMPXPdPlaybackViewImp() + { + // Do nothing + } + +// --------------------------------------------------------------------------- +// Symbian 2nd phase constructor can leave. +// --------------------------------------------------------------------------- +// +void CMPXPdPlaybackViewImp::ConstructL() + { + MPX_FUNC( "CMPXPdPlaybackViewImp::ConstructL" ); + + CMPXCommonPlaybackViewImp::ConstructL(); + + // Need to set a higher priority because download manager sets it's + // own priority high, so we need to make sure we're at least the same + iPlaybackUtility->SetPriority( CActive::EPriorityStandard + 2 ); + + CCoeEnv* coeEnv = iEikonEnv; + TParse parse; + parse.Set( KMPXPdPlaybackRscPath, &KDC_APP_RESOURCE_DIR, NULL ); + TFileName resourceFile = parse.FullName(); + User::LeaveIfError( MPXUser::CompleteWithDllPath( resourceFile ) ); + BaflUtils::NearestLanguageFile( coeEnv->FsSession(), resourceFile ); + iPdResourceOffset = coeEnv->AddResourceFileL( resourceFile ); + + BaseConstructL( R_MPX_PD_PLAYBACK_VIEW ); + if(AknLayoutUtils::PenEnabled()) + { + CAknView::ShowToolbarOnViewActivation(ETrue); + if ( Toolbar() ) + { + iToolbar = Toolbar(); + iToolbar->SetToolbarObserver( this ); + } + } + } + +// --------------------------------------------------------------------------- +// Two-phased constructor. +// --------------------------------------------------------------------------- +// +CMPXPdPlaybackViewImp* CMPXPdPlaybackViewImp::NewL() + { + CMPXPdPlaybackViewImp* self = CMPXPdPlaybackViewImp::NewLC(); + CleanupStack::Pop( self ); + return self; + } + +// --------------------------------------------------------------------------- +// Two-phased constructor. +// --------------------------------------------------------------------------- +// +CMPXPdPlaybackViewImp* CMPXPdPlaybackViewImp::NewLC() + { + CMPXPdPlaybackViewImp* self = new ( ELeave ) CMPXPdPlaybackViewImp(); + CleanupStack::PushL( self ); + self->ConstructL(); + return self; + } + +// --------------------------------------------------------------------------- +// Destructor +// --------------------------------------------------------------------------- +// +CMPXPdPlaybackViewImp::~CMPXPdPlaybackViewImp() + { + MPX_DEBUG1( "CMPXPdPlaybackViewImp::~CMPXPdPlaybackViewImp entering" ); + + delete iPlaybackViewLayout; + + if ( iPdResourceOffset ) + { + iEikonEnv->DeleteResourceFile( iPdResourceOffset ); + } + + MPX_DEBUG1( "CMPXPdPlaybackViewImp::~CMPXPdPlaybackViewImp exiting" ); + } + + +// --------------------------------------------------------------------------- +// Gets download information +// --------------------------------------------------------------------------- +// +void CMPXPdPlaybackViewImp::GetDownloadInformationL( + TUint& aTransactionId, + TMPXPlaybackPdDownloadState& aState, + TInt& aDownloadedBytes, + TInt& aTotalBytes ) + { + MPX_DEBUG1("CMPXPdPlaybackViewImp::GetDownloadInformationL() entering"); + + // Create the command to send to MPX + CMPXCommand* cmd( CMPXCommand::NewL() ); + CleanupStack::PushL( cmd ); + cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, ETrue ); + cmd->SetTObjectValueL( KMPXCommandGeneralId, KMPXCommandIdPlaybackPD ); + cmd->SetTObjectValueL( KMPXCommandPlaybackGeneralType, EPbCmdGetPdStatus ); + iPlaybackUtility->CommandL( *cmd ); + + // Check that return values were provided, if not, playback plugin is messed up. + if ( !cmd->IsSupported( KMPXCommandPlaybackPDTransactionID ) || + !cmd->IsSupported( KMPXCommandPlaybackPDState ) || + !cmd->IsSupported( KMPXCommandPlaybackPDDownloadedBytes ) || + !cmd->IsSupported( KMPXCommandPlaybackPDTotalBytes ) ) + { + aState = EPbDlStateDownloadError; + CleanupStack::PopAndDestroy( cmd ); + MPX_DEBUG1("CMPXPdPlaybackViewImp::GetDownloadInformationL() Error in Command info"); + return; + } + + // Copy the return values + aTransactionId = cmd->ValueTObjectL( KMPXCommandPlaybackPDTransactionID ); + aState = cmd->ValueTObjectL( KMPXCommandPlaybackPDState ); + aDownloadedBytes = cmd->ValueTObjectL( KMPXCommandPlaybackPDDownloadedBytes ); + aTotalBytes = cmd->ValueTObjectL( KMPXCommandPlaybackPDTotalBytes ); + CleanupStack::PopAndDestroy( cmd ); + + MPX_DEBUG1("CMPXPdPlaybackViewImp::GetDownloadInformationL() exiting"); + } + +// ----------------------------------------------------------------------------- +// CMPXPdPlaybackViewImp::CheckSignalAvailableL +// This checks for Network available, and Network Strength > none. +// - Return ETrue if network available and network strength +// is Low or Medium or High, otherwise return EFalse. +// ----------------------------------------------------------------------------- +// +TBool CMPXPdPlaybackViewImp::CheckSignalAvailableL( TUid& aCheck, TInt& aState ) + { + TBool ret( ETrue ); + + // Check the network is available. + aCheck = KUidNetworkStatus; + TInt err( RProperty::Get( KUidSystemCategory, KUidNetworkStatusValue, aState )); + if ( err != KErrNone ) + { + aState = ESANetworkUnAvailable; + } + if( aState != ESANetworkAvailable ) + { + ret = EFalse; + } + + // Check network coverage. + aCheck = KUidNetworkStrength; + err = RProperty::Get( KUidSystemCategory, KUidNetworkStrengthValue, aState ); + if ( err != KErrNone ) + { + aState = ESANetworkStrengthUnknown; + } + if( aState != ESANetworkStrengthLow && + aState != ESANetworkStrengthMedium && + aState != ESANetworkStrengthHigh ) + { + ret = EFalse; + } + + //passed all tests, OK to send + return ret; + } + +// --------------------------------------------------------------------------- +// Handle playback message. +// --------------------------------------------------------------------------- +// +void CMPXPdPlaybackViewImp::DoHandlePlaybackMessageL( + const CMPXMessage& aMessage ) + { + MPX_FUNC( "-->CMPXPdPlaybackViewImp::DoHandlePlaybackMessageL" ); + + TMPXMessageId id( aMessage.ValueTObjectL( KMPXMessageGeneralId ) ); + if ( KMPXMessageGeneral == id ) + { + TInt type( aMessage.ValueTObjectL( KMPXMessageGeneralType ) ); + TInt data( aMessage.ValueTObjectL( KMPXMessageGeneralData ) ); + MPX_DEBUG2( "CMPXPdPlaybackViewImp::DoHandlePlaybackMessageL type = %d", type ); + switch ( aMessage.ValueTObjectL( KMPXMessageGeneralEvent ) ) + { + case TMPXPlaybackMessage::EDownloadPositionChanged: + { + if ( iContainer ) + { + MPX_DEBUG2( "CMPXPdPlaybackViewImp::DoHandlePlaybackMessageL - EDownloadPositionChanged(%d)", data ); + CMPXPdPlaybackViewContainer* container = + static_cast(iContainer); + container->HandleDownloadPositionChanged( data, iTotalBytes ); + } + break; + } + case TMPXPlaybackMessage::EDownloadStateChanged: + { + MPX_DEBUG2( "CMPXPdPlaybackViewImp::DoHandlePlaybackMessageL - EDownloadStateChanged(%d)", data ); + iDownloadState = static_cast( data ); + if ( iDownloadState == EPbDlStateDownloading || + iDownloadState == EPbDlStateDownloadCompleted ) + { + RequestMediaL(); + } + if( iContainer && iDownloadState == EPbDlStateDownloadCompleted ) + { + CMPXPdPlaybackViewContainer* container = + static_cast(iContainer); + container->HandleDownloadPositionChanged( iTotalBytes, iTotalBytes ); + } + UpdateViewL(); + break; + } + case TMPXPlaybackMessage::EStateChanged: + { + MPX_DEBUG2( "CMPXPdPlaybackViewImp::DoHandlePlaybackMessageL - EStateChanged(%d)", type ); + + UpdateMiddleSoftKeyDisplayL(); + UpdateToolbar(); + TMPXPlaybackState state = + static_cast( type ); + DoHandleStateChangedL( state, data ); + break; + } + case TMPXPlaybackMessage::EDownloadStarted: + { + iTotalBytes = aMessage.ValueTObjectL( KMPXMessageGeneralData ); + MPX_DEBUG2( "CMPXPdPlaybackViewImp::DoHandlePlaybackMessageL - DownloadStarted, totalBytes = %d", iTotalBytes ); + break; + } + default: + { + CMPXCommonPlaybackViewImp::DoHandlePlaybackMessageL( aMessage ); + break; + } + } + } + MPX_DEBUG1("<--CMPXPdPlaybackViewImp::DoHandlePlaybackMessageL()"); + } + +// --------------------------------------------------------------------------- +// Handle playback state changed. +// --------------------------------------------------------------------------- +// +void CMPXPdPlaybackViewImp::DoHandleStateChangedL( + TMPXPlaybackState aState, + TInt aData ) + { + MPX_DEBUG2( "CMPXPdPlaybackViewImp::DoHandleStateChangedL(%d)", aState ); + + switch ( aState ) + { + case EPbStateInitialising: + { + UpdatePlaybackState( aState ); + UpdateDownloadStateLabelL(); + RequestMediaL(); + break; + } + case EPbStatePaused: + { + //Show the note only when all content played (disconnected and buffer empty), not on user Pause. + if ( iContainer && KErrUnderflow == aData && EPbDlStateDownloadPaused == iDownloadState ) + { + iCommonUiHelper->DisplayInfoNoteL( R_MPX_DOWNLOAD_PLAYED_ALL_CONTENT ); + } + // fall through on purpose + } + default: + { + CMPXCommonPlaybackViewImp::DoHandleStateChangedL( aState, aData ); + break; + } + } + MPX_DEBUG1("CMPXPdPlaybackViewImp::DoHandleStateChangedL()"); + } + +// --------------------------------------------------------------------------- +// Updates download state label. +// --------------------------------------------------------------------------- +// +void CMPXPdPlaybackViewImp::UpdateDownloadStateLabelL() + { + MPX_DEBUG1("CMPXPdPlaybackViewImp::UpdateDownloadStateLabelL() entering"); + + if ( iContainer && !iSwitchingView ) + { + TInt resId = KErrNotFound; + switch ( iDownloadState ) + { + case EPbDlStateBuffering: + { + MPX_DEBUG1("CMPlayerPlaybackContainer::UpdateDownloadStateLabelL() - Buffering"); + resId = R_MPX_DOWNLOAD_STATUS_BUFFERING; + break; + } + case EPbDlStateDownloadPaused: + { + // If offline mode, this case will be entered. + resId = R_MPX_DOWNLOAD_STATUS_PAUSED; + TBool offLine( EFalse ); + + // Check profile, display "Download Stopped" if + // Offline enabled. + MProfileEngine* profileEngine( CreateProfileEngineL() ); + + if ( profileEngine->ActiveProfileId() == EProfileOffLineId ) + { + MPX_DEBUG1("CMPXPdPlaybackViewImp::UpdateDownloadStateLabelL() -- OffLine "); + offLine = ETrue; + resId = R_MPX_DOWNLOAD_STATUS_INTERRUPTED; + } + profileEngine->Release(); + + if ( !offLine ) + { + // Check network coverage, display "Download Stopped" if + // No coverage. + TUid uid; + TInt res( 0 ); + TBool signalAvailable( CheckSignalAvailableL( uid, res )); + + if ( !signalAvailable ) + { + MPX_DEBUG1("CMPXPdPlaybackViewImp::UpdateDownloadStateLabelL() -- No Signal "); + resId = R_MPX_DOWNLOAD_STATUS_INTERRUPTED; + } + } + break; + } + case EPbDlStateDownloadError: + case EPbDlStateDownloadCanceled: + case EPbDlStateNotDownloading: + { + MPX_DEBUG1("CMPlayerPlaybackContainer::UpdateDownloadStateLabelL() - Download Canceled"); + resId = R_MPX_DOWNLOAD_STATUS_INTERRUPTED; + break; + } + case EPbDlStateDownloadCompleted: + { + MPX_DEBUG1("CMPlayerPlaybackContainer::UpdateDownloadStateLabelL() - Download Completed"); + resId = R_MPX_DOWNLOAD_STATUS_COMPLETED; + break; + } + case EPbDlStateDownloading: + default: + { + MPX_DEBUG2(" default state: %d", iDownloadState ); + // Do nothing + break; + } + } +/* + // Display Album art in progressive download + if( iActualAlbumArtBitmap ) + { + MPX_DEBUG1("CMPlayerPlaybackContainer::UpdateDownloadStateLabelL() - Draw ActualAlbumArt"); + iAlbumArtBitmap = iActualAlbumArtBitmap; + DrawNow(); + } + else + { + MPX_DEBUG1("CMPlayerPlaybackContainer::UpdateDownloadStateLabelL() - Draw DefaultAlbumArt"); + // Display default Album Art + iAlbumArtBitmap = iDefaultAlbumArtBitmap; + DrawNow(); + } +*/ + + if (resId != KErrNotFound) + { + // Display download status text + HBufC* statusText = StringLoader::LoadLC( resId ); + iContainer->UpdateLabelL( ETextDownloadState, *statusText ); + CleanupStack::PopAndDestroy( statusText ); + } + else + { + // Clear download status text + iContainer->UpdateLabelL( ETextDownloadState, KNullDesC ); + } + } + + MPX_DEBUG1("CMPXPdPlaybackViewImp::UpdateDownloadStateLabelL() exiting"); + } + +// --------------------------------------------------------------------------- +// Displays error notes. +// --------------------------------------------------------------------------- +// +void CMPXPdPlaybackViewImp::HandleErrorL( TInt aError ) + { + MPX_DEBUG2("CMPXPdPlaybackViewImp::HandleErrorL(%d): Entering", aError); + if ( aError ) + { + TUint transactionId(0); + TMPXPlaybackPdDownloadState state( EPbDlStateNotDownloading ); + TInt downloadedBytes(0); + TInt totalBytes(0); + GetDownloadInformationL( transactionId, + state, + downloadedBytes, + totalBytes ); + if ( EPbDlStateBuffering == state || + EPbDlStateDownloading == state || + EPbDlStateDownloadPaused == state ) + { + CMPXCommand* cmd( CMPXCommand::NewL() ); + CleanupStack::PushL( cmd ); + cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, ETrue ); + cmd->SetTObjectValueL( KMPXCommandGeneralId, KMPXCommandIdPlaybackPD ); + cmd->SetTObjectValueL( + KMPXCommandPlaybackGeneralType, + EPbCmdCancelPd ); + iPlaybackUtility->CommandL( *cmd ); + CleanupStack::PopAndDestroy( cmd ); + } + iCommonUiHelper->HandleErrorL( aError ); + CMPXCommonPlaybackViewImp::HandleCommandL( EAknSoftkeyBack ); + } + } + +// --------------------------------------------------------------------------- +// From MEikMenuObserver +// Dynamically initialises a menu pane. +// --------------------------------------------------------------------------- +// +void CMPXPdPlaybackViewImp::DynInitMenuPaneL( + TInt aResourceId, + CEikMenuPane* aMenuPane ) + { + MPX_DEBUG2("CMPXPdPlaybackViewImp::DynInitMenuPaneL(%d): entering", aResourceId); + + // Override base menu actions + switch ( aResourceId ) + { + case R_MPX_PD_PLAYBACK_VIEW_MENU: + { + aMenuPane->SetItemDimmed( + EMPXPbvCmdResumeDownload, + iDownloadState != EPbDlStateDownloadPaused); + aMenuPane->SetItemDimmed( + EMPXPbvCmdCancelDownload, + iDownloadState != EPbDlStateDownloading && + iDownloadState != EPbDlStateBuffering && + iDownloadState != EPbDlStateDownloadPaused); + + // Check if FM Transmitter is supported + if ( !FeatureManager::FeatureSupported( KFeatureIdFmtx ) ) + { + aMenuPane->SetItemDimmed( + EMPXPbvCmdFMTransmitter, + ETrue ); + } + break; + } + default: + { + // Call base clase to handle most cases + CMPXCommonPlaybackViewImp::DynInitMenuPaneL( aResourceId, aMenuPane ); + break; + } + } + + MPX_DEBUG1("CMPXPdPlaybackViewImp::DynInitMenuPaneL(): exiting"); + } + +// --------------------------------------------------------------------------- +// From CAknView +// Command handling function. +// --------------------------------------------------------------------------- +// +void CMPXPdPlaybackViewImp::HandleCommandL( TInt aCommand ) + { + MPX_DEBUG2("CMPXPdPlaybackViewImp::HandleCommandL(%d) entering", aCommand); + + switch (aCommand) + { + case EMPXPbvCmdResumeDownload: + { + if ( EPbDlStateDownloadPaused == iDownloadState ) + { + CMPXCommand* cmd( CMPXCommand::NewL() ); + CleanupStack::PushL( cmd ); + cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, ETrue ); + cmd->SetTObjectValueL( KMPXCommandGeneralId, KMPXCommandIdPlaybackPD ); + cmd->SetTObjectValueL( + KMPXCommandPlaybackGeneralType, + EPbCmdResumePd ); + iPlaybackUtility->CommandL( *cmd ); + CleanupStack::PopAndDestroy( cmd ); + } + break; + } + case EMPXPbvCmdCancelDownload: + { + if ( EPbDlStateDownloading == iDownloadState || + EPbDlStateBuffering == iDownloadState || + EPbDlStateDownloadPaused == iDownloadState ) + { + HBufC* queryTxt = StringLoader::LoadLC( R_MPX_CONF_CANCEL_DOWNLOAD_TXT ); + CAknQueryDialog* query = CAknQueryDialog::NewL( + CAknQueryDialog::EConfirmationTone ); + +/* TODO: add when we support cover UI + query->PublishDialogL( + EMPXNoteMusicshopCancel, +*/ + + if ( query->ExecuteLD( + R_MPX_GENERIC_CONFIRMATION_QUERY, + *queryTxt )) + { + iPlaybackUtility->CommandL( EPbCmdClose ); + CMPXCommand* cmd( CMPXCommand::NewL() ); + CleanupStack::PushL( cmd ); + cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, ETrue ); + cmd->SetTObjectValueL( KMPXCommandGeneralId, KMPXCommandIdPlaybackPD ); + cmd->SetTObjectValueL( + KMPXCommandPlaybackGeneralType, + EPbCmdCancelPd ); + iPlaybackUtility->CommandL( *cmd ); + CleanupStack::PopAndDestroy( cmd ); + + // Close PD view and go back to host application + AppUi()->HandleCommandL( EAknSoftkeyBack ); + } + } + break; + } + case EAknSoftkeyBack: + { + TUint ignore1(0); + TMPXPlaybackPdDownloadState state( EPbDlStateNotDownloading ); + TInt ignore2(0); + + GetDownloadInformationL( ignore1, + state, + ignore2, + ignore2); + if ( EPbDlStateDownloadCompleted == state && + ( EPbStatePaused == iPlaybackState || + EPbStateStopped == iPlaybackState )) + { + CMPXCommand* cmd( CMPXCommand::NewL() ); + CleanupStack::PushL( cmd ); + cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, ETrue ); + cmd->SetTObjectValueL( KMPXCommandGeneralId, KMPXCommandIdPlaybackPD ); + cmd->SetTObjectValueL( + KMPXCommandPlaybackGeneralType, + EPbCmdFinishPd ); + iPlaybackUtility->CommandL( *cmd ); + CleanupStack::PopAndDestroy( cmd ); + } + } // fall through + default: + { + CMPXCommonPlaybackViewImp::HandleCommandL( aCommand ); + break; + } + } + + MPX_DEBUG1("CMPXPdPlaybackViewImp::HandleCommandL() exiting"); + } + +// --------------------------------------------------------------------------- +// Handle playback property. +// --------------------------------------------------------------------------- +// +void CMPXPdPlaybackViewImp::DoHandlePropertyL( + TMPXPlaybackProperty aProperty, + TInt aValue, + TInt aError ) + { + MPX_FUNC( "CMPXPdPlaybackViewImp::DoHandlePropertyL" ); + MPX_DEBUG4( "HandlePropertyL - Property(%d); Value(%d); Error(%d)", aProperty, aValue, aError ); + + if ( KErrNone == aError ) + { + switch ( aProperty ) + { + case EPbPropertyRandomMode: + case EPbPropertyRepeatMode: + // ignore these cases in PD + break; + default: + { + CMPXCommonPlaybackViewImp::DoHandlePropertyL(aProperty,aValue,aError); + break; + } + } + } + else + { + HandleErrorL( aError ); + } + } + +// --------------------------------------------------------------------------- +// From CAknView +// Returns views id. +// --------------------------------------------------------------------------- +// +TUid CMPXPdPlaybackViewImp::Id() const + { + return TUid::Uid( KMPXPdPlaybackViewId ); + } + +// --------------------------------------------------------------------------- +// From CAknView +// Processes user commands. +// --------------------------------------------------------------------------- +// +void CMPXPdPlaybackViewImp::ProcessCommandL( TInt aCommand ) + { + MPX_DEBUG2("CMPXPdPlaybackViewImp::ProcessCommandL(%d): entering", aCommand); + if ( aCommand == EAknCmdExit ) + { + if ( MenuBar() ) + { + MenuBar()->StopDisplayingMenuBar(); + } + } + CAknView::ProcessCommandL( aCommand ); + MPX_DEBUG1("CMPXPdPlaybackViewImp::ProcessCommandL(): exiting"); + } + +// --------------------------------------------------------------------------- +// From CAknView +// Handles a view activation. +// --------------------------------------------------------------------------- +// +void CMPXPdPlaybackViewImp::DoActivateL( + const TVwsViewId& aPrevViewId, + TUid aCustomMessageId, + const TDesC8& aCustomMessage ) + { + MPX_FUNC( "CMPXPdPlaybackViewImp::DoActivateL()" ); + + if ( !iContainer ) + { + if ( !iPlaybackViewLayout ) + { + iPlaybackViewLayout = CMPXPdPlaybackViewLayout::NewL(); + } + iContainer = new ( ELeave ) CMPXPdPlaybackViewContainer( + this, + this, + iPlaybackViewLayout ); + iContainer->SetMopParent( this ); + iContainer->ConstructL( ClientRect() ); + AppUi()->AddToStackL( *this, iContainer ); + } + + CMPXCommonPlaybackViewImp::DoActivateL( aPrevViewId , aCustomMessageId, aCustomMessage ); + UpdateMiddleSoftKeyDisplayL(); + } + + +// ----------------------------------------------------------------------------- +// From MAknToolbarObserver +// Used to change toolbar settings before toolbar becomes visible +// ----------------------------------------------------------------------------- +// +void CMPXPdPlaybackViewImp::DynInitToolbarL(TInt aResourceId, CAknToolbar* aToolbar) + { + if(aResourceId == R_MPX_PBV_TOUCH_TOOLBAR) + { + // Put initializations here to take effect before toolbar is shown + aToolbar->SetItemDimmed( EMPXPbvCmdPreviousListItem, ETrue, EFalse ); + aToolbar->SetItemDimmed( EMPXPbvCmdNextListItem, ETrue, EFalse ); + UpdateToolbar(); + aToolbar->UpdateBackground(); + } + } + +// ----------------------------------------------------------------------------- +// From MAknToolbarObserver +// Handles toolbar events +// ----------------------------------------------------------------------------- +// +void CMPXPdPlaybackViewImp::OfferToolbarEventL( TInt aCommandId ) + { + CAknView::ProcessCommandL( aCommandId ); + } + +// --------------------------------------------------------------------------- +// Updates the middle toolbar button +// --------------------------------------------------------------------------- +// +void CMPXPdPlaybackViewImp::UpdateToolbar() + { + MPX_FUNC( "CMPXPdPlaybackViewImp::UpdateToolbar" ); + + if ( AknLayoutUtils::PenEnabled() && Toolbar()) + { + CAknToolbar* toolbar = Toolbar(); + TBool pausePlayDimmed(ETrue); + MMPXSource* s = iPlaybackUtility->Source(); + if ( s ) + { + TMPXPlaybackState state = iPlaybackUtility->StateL(); + CAknButton* pausePlayControl; + pausePlayControl = (CAknButton*)(toolbar->ComponentControl( 1 )); + if ((state == EPbStateInitialising) || (state == EPbStatePlaying)) + { + pausePlayControl->SetCurrentState(0, ETrue); + } + else + { + pausePlayControl->SetCurrentState(1, ETrue); + } + if ( state == EPbStatePlaying || + state == EPbStatePaused || + state == EPbStateStopped ) + { + pausePlayDimmed = EFalse; + } + } + toolbar->SetItemDimmed( EMPXPbvCmdPlayPause, pausePlayDimmed, ETrue ); + } + } +// End of File