diff -r 839377eedc2b -r befca0ec475f videoplayback/videoplaybackviews/src/mpxvideopdlplaybackview.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/videoplayback/videoplaybackviews/src/mpxvideopdlplaybackview.cpp Wed Sep 01 12:30:28 2010 +0100 @@ -0,0 +1,578 @@ +/* +* Copyright (c) 2008 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 Video playback view +* +*/ + + +// Version : %version: 30 % + + +// Include Files +#include +#include +#include +#include +#include +#include +#include +#include + +#include "mpxcommonvideoplaybackview.hrh" +#include "mpxvideoplaybackuids.hrh" +#include "mpxvideopdlplaybackview.h" +#include "mpxvideoplaybackcontainer.h" +#include "mpxvideoplaybackviewfiledetails.h" +#include "mpxvideoplaybackuserinputhandler.h" +#include +#include "mpxvideo_debug.h" + +// Member Functions + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPdlPlaybackView::NewLC() +// ------------------------------------------------------------------------------------------------- +// +EXPORT_C CMPXVideoPdlPlaybackView* CMPXVideoPdlPlaybackView::NewLC() +{ + MPX_ENTER_EXIT(_L("CMPXVideoPdlPlaybackView::NewLC()")); + + CMPXVideoPdlPlaybackView* self = new (ELeave) CMPXVideoPdlPlaybackView(); + CleanupStack::PushL( self ); + self->ConstructL(); + return self; +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPdlPlaybackView::NewL() +// ------------------------------------------------------------------------------------------------- +// +EXPORT_C CMPXVideoPdlPlaybackView* CMPXVideoPdlPlaybackView::NewL() +{ + CMPXVideoPdlPlaybackView* self = CMPXVideoPdlPlaybackView::NewLC(); + CleanupStack::Pop( self ); + return self; +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPdlPlaybackView::CMPXVideoPdlPlaybackView() +// ------------------------------------------------------------------------------------------------- +// +CMPXVideoPdlPlaybackView::CMPXVideoPdlPlaybackView() +// note, CBase initialises all member variables to zero +{ +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPdlPlaybackView::ConstructL() +// ------------------------------------------------------------------------------------------------- +// +void CMPXVideoPdlPlaybackView::ConstructL() +{ + MPX_ENTER_EXIT(_L("CMPXVideoPdlPlaybackView::ConstructL()")); + + InitializeVideoPlaybackViewL(); + + iBlockInputsTimer = CPeriodic::NewL( CActive::EPriorityStandard ); + + iSyncClose = ETrue; +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPdlPlaybackView::~CMPXVideoPdlPlaybackView() +// ------------------------------------------------------------------------------------------------- +// +CMPXVideoPdlPlaybackView::~CMPXVideoPdlPlaybackView() +{ + MPX_DEBUG(_L("CMPXVideoPdlPlaybackView::~CMPXVideoPdlPlaybackView()")); + + if ( iBlockInputsTimer ) + { + iBlockInputsTimer->Cancel(); + delete iBlockInputsTimer; + iBlockInputsTimer = NULL; + } +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPdlPlaybackView::Id() +// ------------------------------------------------------------------------------------------------- +// +TUid CMPXVideoPdlPlaybackView::Id() const +{ + return TUid::Uid( KMPXVIDEOPDLPLAYBACKVIEWUID ); +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPdlPlaybackView::ViewImplementationIdId() +// ------------------------------------------------------------------------------------------------- +// +TUid CMPXVideoPdlPlaybackView::ViewImplementationId() const +{ + return TUid::Uid( KMPXVIDEOPDLPLAYBACKVIEWPLUGINIMPLEMENTATIONUID ); +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPdlPlaybackView::CloseEmbeddedPlaybackViewL +// ------------------------------------------------------------------------------------------------- +// +void CMPXVideoPdlPlaybackView::CloseEmbeddedPlaybackViewL() +{ + MPX_ENTER_EXIT(_L("CMPXVideoPdlPlaybackView::CloseEmbeddedPlaybackViewL()"), + _L("iPlaybackState = %d"), iPlaybackState ); + + // + // If playback state is playing, pause playback + // If playback state is stopped, close the plugin so file will be moved + // + if ( iPlaybackState == EPbStatePlaying ) + { + HandleCommandL( EMPXPbvCmdPause ); + } + else if ( iPlaybackState == EPbStateStopped ) + { + ActivateClosePlayerActiveObject(); + } + + // + // Embedded PDL + // If we are in the foreground, bring the browser to the foreground + // + if ( ! BringUpBrowserL() ) + { + // + // Browser cannot be found, exit application + // + AppUi()->RunAppShutter(); + } +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPdlPlaybackView::BringUpBrowserL +// ------------------------------------------------------------------------------------------------- +// +TBool CMPXVideoPdlPlaybackView::BringUpBrowserL() +{ + MPX_ENTER_EXIT(_L("CMPXVideoPdlPlaybackView::BringUpBrowserL()")); + + TBool browserFound( EFalse ); + + RWsSession& wsSession=iEikonEnv->WsSession(); + CAknTaskList* taskList = CAknTaskList::NewL( wsSession ); + TApaTask task = taskList->FindRootApp( TUid::Uid( KBROWSERUID ) ); + + delete taskList; + + if ( task.Exists() ) + { + task.BringToForeground(); + browserFound = ETrue; + } + + return browserFound; +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPdlPlaybackView::RetrievePdlInformationL +// ------------------------------------------------------------------------------------------------- +// +void CMPXVideoPdlPlaybackView::RetrievePdlInformationL() +{ + MPX_ENTER_EXIT(_L("CMPXVideoPdlPlaybackView::RetrievePdlInformationL()")); + + CMPXCommand* cmd( CMPXCommand::NewL() ); + CleanupStack::PushL( cmd ); + + cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, ETrue ); + cmd->SetTObjectValueL( KMPXCommandGeneralId, KMPXCommandIdPlaybackPD ); + cmd->SetTObjectValueL( KMPXCommandPlaybackGeneralType, + EPbCmdGetPdStatus ); + + iPlaybackUtility->CommandL( *cmd ); + + // + // Parse the PDL information + // + iPdlState = cmd->ValueTObjectL( KMPXCommandPlaybackPDState ); + TInt downloadedBytes = cmd->ValueTObjectL( KMPXCommandPlaybackPDDownloadedBytes ); + iDownloadSize = cmd->ValueTObjectL( KMPXCommandPlaybackPDTotalBytes ); + + MPX_DEBUG(_L(" PDL State = %d, current size = %d, total size = %d"), + iPdlState, downloadedBytes, iDownloadSize ); + + CleanupStack::PopAndDestroy( cmd ); + + if ( iContainer ) + { + // + // Check for a saved download. + // The download size and downloaded bytes will be set to 100 so + // the download progress bar will show 100% + // + if ( iPdlState == EPbDlStateNotDownloading || iPdlState == EPbDlStateDownloadCompleted ) + { + iDownloadSize = 100; + downloadedBytes = 100; + } + + iContainer->HandleEventL( EMPXControlCmdSetDownloadSize, iDownloadSize ); + iContainer->HandleEventL( EMPXControlCmdDownloadUpdated, downloadedBytes ); + } +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPdlPlaybackView::HandlePluginErrorL() +// ------------------------------------------------------------------------------------------------- +// +void CMPXVideoPdlPlaybackView::HandlePluginErrorL( TInt aError ) +{ + MPX_DEBUG( + _L("CMPXVideoPdlPlaybackView::HandlePluginErrorL() aError = %d"), aError ); + + switch ( aError ) + { + case KErrAbort: + { + // + // For progressive download mode, this indicates that the file + // could not be played until the entire file is downloaded. + // + DisplayInfoMessageL( R_MPX_VIDEO_PDL_WAIT_DL_COMPLETE_MSG, ETrue ); + ClosePlaybackViewWithErrorL(); + + break; + } + case KErrEof: + { + // + // For progressive download mode, this indicates that the file + // has timed out waiting for more data to be downloaded + // + DisplayErrorMessageL( R_MPX_VIDEO_PDL_ALL_CONTENT_PLAYED_MSG ); + ClosePlaybackViewWithErrorL(); + + break; + } + case KErrNotSupported: + case KErrUnknown: + case KErrMMDecoder: + case KErrCorrupt: + case KErrTooBig: + { + // + // We have received an error for an invalid clip. + // If the download is complete, display the invalid + // clip message. If the download is in progress, + // we do not know if the clip is invalid yet. + // Show message to wait for more data. + // + if ( iPdlState >= EPbDlStateNotDownloading ) + { + DisplayErrorMessageL( R_MPX_PDL_MORE_DATA_NEEDED_MSG ); + } + else + { + DisplayErrorMessageL( R_MPX_VIDEO_INVALID_CLIP ); + } + + ClosePlaybackViewWithErrorL(); + + break; + } + default: + { + CMPXVideoBasePlaybackView::HandlePluginErrorL( aError ); + } + } +} + +// ----------------------------------------------------------------------------- +// CMPXVideoPdlPlaybackView::HandlePdlStateChangeL +// ----------------------------------------------------------------------------- +// +void CMPXVideoPdlPlaybackView::HandlePdlStateChangeL( TInt aState ) +{ + MPX_ENTER_EXIT(_L("CMPXVideoPdlPlaybackView::HandlePdlStateChangeL()"), + _L("aState = %d"), aState ); + + TMPXPlaybackPdDownloadState prevPdlState = iPdlState; + iPdlState = (TMPXPlaybackPdDownloadState)aState; + + switch ( aState ) + { + case EPbDlStateDownloadError: + case EPbDlStateDownloadCanceled: + { + HandleCommandL( EMPXPbvCmdStop ); + ClosePlaybackViewWithErrorL(); + break; + } + case EPbDlStateDownloading: + { + if ( prevPdlState == EPbDlStateDownloadPaused ) + { + if ( iContainer ) + { + iContainer->HandleEventL( EMPXControlCmdClearDownloadPaused ); + } + } + + break; + } + case EPbDlStateDownloadPaused: + { + // + // If we are buffering, display information message and pause + // + if ( iPlaybackState == EPbStateBuffering ) + { + HandleCommandL( EMPXPbvCmdPause ); + + DisplayInfoMessageL( R_MPX_VIDEO_PDL_ALL_CONTENT_PLAYED_MSG, ETrue ); + HandleCommandL( EAknSoftkeyBack ); + } + else + { + // + // Download has been paused, let container show + // the download paused icon + // + if ( iContainer ) + { + iContainer->HandleEventL( EMPXControlCmdSetDownloadPaused ); + } + } + + break; + } + case EPbDlStateDownloadCompleted: + { + if ( iContainer ) + { + iContainer->HandleEventL( EMPXControlCmdDownloadComplete, iDownloadSize ); + } + + break; + } + case EPbDlStateNotDownloading: + { + break; + } + } +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPdlPlaybackView::HandleStoppedStateL +// ------------------------------------------------------------------------------------------------- +// +void CMPXVideoPdlPlaybackView::HandleStoppedStateL() +{ + MPX_DEBUG(_L("CMPXVideoPdlPlaybackView::HandleStoppedStateL()")); + + if ( iPdlReloading ) + { + iPdlReloading = EFalse; + } + else + { + ClosePlaybackViewL(); + } +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPdlPlaybackView::HandleBufferingStateL +// ------------------------------------------------------------------------------------------------- +// +void CMPXVideoPdlPlaybackView::HandleBufferingStateL() +{ + MPX_DEBUG(_L("CMPXVideoPdlPlaybackView::HandleBufferingStateL()")); + + // + // If the download is paused and the state is buffering, + // display information message + // + if ( iPdlState == EPbDlStateDownloadPaused ) + { + HandleCommandL( EMPXPbvCmdPause ); + + DisplayInfoMessageL( R_MPX_VIDEO_PDL_ALL_CONTENT_PLAYED_MSG, ETrue ); + HandleCommandL( EAknSoftkeyBack ); + } +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPdlPlaybackView::SendPdlCustomCommandL() +// ------------------------------------------------------------------------------------------------- +// +void CMPXVideoPdlPlaybackView::SendPdlCustomCommandL( TMPXPlaybackPdCommand aCustomCmd ) +{ + MPX_ENTER_EXIT(_L("CMPXVideoPdlPlaybackView::SendPdlCustomCommandL"), + _L("aCustomCmd = %d"), aCustomCmd ); + + CMPXCommand* cmd = CMPXCommand::NewL(); + CleanupStack::PushL( cmd ); + + cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, ETrue ); + cmd->SetTObjectValueL( KMPXCommandGeneralId, KMPXCommandIdPlaybackPD ); + cmd->SetTObjectValueL( KMPXCommandPlaybackGeneralType, aCustomCmd ); + + iPlaybackUtility->CommandL( *cmd ); + + CleanupStack::PopAndDestroy( cmd ); +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPdlPlaybackView::ClosePlaybackViewWithErrorL() +// ------------------------------------------------------------------------------------------------- +// +void CMPXVideoPdlPlaybackView::ClosePlaybackViewWithErrorL() +{ + MPX_ENTER_EXIT(_L("CMPXVideoPdlPlaybackView::ClosePlaybackViewWithErrorL")); + + // + // An error has been processed, set the playback state to Stopped and close the view + // + iPlaybackState = EPbStateStopped; + + ClosePlaybackViewL(); +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPdlPlaybackView::HandleInitializingStateL() +// ------------------------------------------------------------------------------------------------- +// +void CMPXVideoPdlPlaybackView::HandleInitializingStateL( TMPXPlaybackState aLastState ) +{ + MPX_ENTER_EXIT(_L("CMPXVideoPdlPlaybackView::HandleInitializingStateL()"), + _L("aLastState = %d"), aLastState ); + + // + // For PDL view, reset the container and controls for new download + // + DoHandleInitializingStateL( aLastState ); + + // + // User inputs should not be blocked since the new download is initializing + // + ResetPdlUserInputs(); +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPdlPlaybackView::SendWindowCommandL() +// ------------------------------------------------------------------------------------------------- +// +void CMPXVideoPdlPlaybackView::SendWindowCommandL( TMPXVideoPlaybackCommand aCmd ) +{ + MPX_ENTER_EXIT(_L("CMPXVideoPdlPlaybackView::SendWindowCommandL()"), + _L("aCmd = %d"), aCmd ); + + CMPXVideoBasePlaybackView::SendWindowCommandL( aCmd ); + + if ( aCmd == EPbCmdHandleForeground ) + { + // + // If user inputs are blocked, start timer to unblock them + // + if ( iUserInputsBlocked ) + { + if ( iBlockInputsTimer->IsActive() ) + { + iBlockInputsTimer->Cancel(); + } + + // + // Set timer to unblock user inputs after 1 second + // The message from the download manager should take less than 1 second + // + iBlockInputsTimer->Start( + 1000000, + 0, + TCallBack( CMPXVideoPdlPlaybackView::HandleBlockInputsTimeOut, this ) ); + } + } + else if ( aCmd == EPbCmdHandleBackground && ! IsAppInFrontL() ) + { + // + // Block all inputs when PDL view is sent to full background + // Commands will be enabled when new command is received from LWP + // + iUserInputsBlocked = ETrue; + iContainer->UserInputHandler()->BlockPdlUserInputs( iUserInputsBlocked ); + } +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPdlPlaybackView::HandlePdlReloadComplete() +// ------------------------------------------------------------------------------------------------- +// +void CMPXVideoPdlPlaybackView::HandlePdlReloadComplete() +{ + MPX_ENTER_EXIT(_L("CMPXVideoPdlPlaybackView::HandlePdlReloadComplete()")); + + // + // User inputs should not be blocked since the new PDL command is complete + // + ResetPdlUserInputs(); +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPdlPlaybackView::ResetPdlUserInputs() +// ------------------------------------------------------------------------------------------------- +// +void CMPXVideoPdlPlaybackView::ResetPdlUserInputs() +{ + MPX_ENTER_EXIT(_L("CMPXVideoPdlPlaybackView::ResetPdlUserInputs()")); + + iUserInputsBlocked = EFalse; + iContainer->UserInputHandler()->BlockPdlUserInputs( iUserInputsBlocked ); + + if ( iBlockInputsTimer->IsActive() ) + { + iBlockInputsTimer->Cancel(); + } +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPdlPlaybackView::HandleBlockInputsTimeOut() +// ------------------------------------------------------------------------------------------------- +// +TInt CMPXVideoPdlPlaybackView::HandleBlockInputsTimeOut( TAny* aPtr ) +{ + MPX_DEBUG(_L("CMPXVideoPdlPlaybackView::HandleBlockInputsTimeOut()")); + + static_cast(aPtr)->DoHandleBlockInputsTimeOut(); + return KErrNone; +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPdlPlaybackView::DoHandleBlockInputsTimeOut() +// ------------------------------------------------------------------------------------------------- +// +void CMPXVideoPdlPlaybackView::DoHandleBlockInputsTimeOut() +{ + // + // Check if we are reloading due to the message from the Download Manager + // If we are still reloading, keep the user inputs blocked. + // If not, unblock the user inputs + // + if ( ! iPdlReloading ) + { + // + // Reload message not received, unblock inputs + // + ResetPdlUserInputs(); + } +} + +// EOF