diff -r 000000000000 -r 96612d01cf9f videoplayback/videohelix/src/mpxvideoplaybackstate.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/videoplayback/videohelix/src/mpxvideoplaybackstate.cpp Mon Jan 18 20:21:12 2010 +0200 @@ -0,0 +1,1873 @@ +/* +* 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: This class plays local video file +* +*/ + +// Version : %version: 30 % + + +// +// INCLUDE FILES +// +#include +#include + +#include "mpxvideoplaybackcontroller.h" +#include "mpxvideoplaybackstate.h" +#include +#include +#include +#include + +#include +#include + +#include "mpxvideoseeker.h" +#include "mpxvideoplayerutility.h" +#include "mpxmediavideodefs.h" + +// +// CONSTANTS +// + +// ============================ MEMBER FUNCTIONS =================================================== + +// ------------------------------------------------------------------------------------------------ +// Symbian 2nd phase constructor can leave. +// ------------------------------------------------------------------------------------------------ +// +void CMPXVideoPlaybackState::ConstructL( CMPXVideoPlaybackController* aVideoPlaybackCtlr ) +{ + MPX_ENTER_EXIT(_L("CMPXVideoPlaybackState::ConstructL()")); + + iVideoPlaybackCtlr = aVideoPlaybackCtlr; + iVideoPlaybackCtlr->iPBPluginError = KErrNone; + + User::LeaveIfError( iFs.Connect() ); + iFs.ShareProtected(); +} + +// ------------------------------------------------------------------------------------------------ +// C++ constructor +// ------------------------------------------------------------------------------------------------ +// +CMPXVideoPlaybackState::CMPXVideoPlaybackState() +{ +} + +// ------------------------------------------------------------------------------------------------ +// Destructor +// ------------------------------------------------------------------------------------------------ +// +CMPXVideoPlaybackState::~CMPXVideoPlaybackState() +{ + MPX_ENTER_EXIT(_L("CMPXVideoPlaybackState::~CMPXVideoPlaybackState()")); + + iFs.Close(); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXVideoPlaybackState::OpenFileL +// ------------------------------------------------------------------------------------------------ +void CMPXVideoPlaybackState::OpenFileL( const TDesC& /*aMediaFile*/ ) +{ + MPX_DEBUG(_L("CMPXVideoPlaybackState::OpenFileL()")); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXVideoPlaybackState::OpenFileL +// ------------------------------------------------------------------------------------------------ +void CMPXVideoPlaybackState::OpenFileL( const RFile& /*aMediaFile*/ ) +{ + MPX_DEBUG(_L("CMPXVideoPlaybackState::OpenFileL()")); +} + +#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API + +// ------------------------------------------------------------------------------------------------ +// CMPXVideoPlaybackState::OpenFile64L +// ------------------------------------------------------------------------------------------------ +void CMPXVideoPlaybackState::OpenFile64L( const RFile64& /*aMediaFile*/ ) +{ + MPX_DEBUG(_L("CMPXVideoPlaybackState::OpenFile64L( RFile64 )")); +} + +#endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API + +// ------------------------------------------------------------------------------------------------ +// CMPXVideoPlaybackState::HandlePlay() +// ------------------------------------------------------------------------------------------------ +void CMPXVideoPlaybackState::HandlePlay() +{ + MPX_DEBUG(_L("CMPXVideoPlaybackState::HandlePlay()")); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXVideoPlaybackState::HandlePause() +// +// @@FP for now we are assuming that Pause is only valid for Playing state +// ------------------------------------------------------------------------------------------------ +void CMPXVideoPlaybackState::HandlePause() +{ + MPX_DEBUG(_L("CMPXVideoPlaybackState::HandlePause()")); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXVideoPlaybackState::HandlePlayPause() +// +// ------------------------------------------------------------------------------------------------ +void CMPXVideoPlaybackState::HandlePlayPause() +{ + MPX_DEBUG(_L("CMPXVideoPlaybackState::HandlePlayPause()")); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXVideoPlaybackState::HandleStop() +// ------------------------------------------------------------------------------------------------ +void CMPXVideoPlaybackState::HandleStop() +{ + MPX_ENTER_EXIT(_L("CMPXVideoPlaybackState::HandleStop()")); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXVideoPlaybackState::HandleClose +// ------------------------------------------------------------------------------------------------ +void CMPXVideoPlaybackState::HandleClose() +{ + MPX_ENTER_EXIT(_L("CMPXVideoPlaybackState::HandleClose()")); + + iVideoPlaybackCtlr->iPlayer->Stop(); + + iVideoPlaybackCtlr->CloseController(); + + iVideoPlaybackCtlr->iMPXPluginObs->HandlePluginEvent( MMPXPlaybackPluginObserver::EPClosed, + 0, + KErrNone ); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXVideoPlaybackState::HandleStartSeekL() +// ------------------------------------------------------------------------------------------------ +void CMPXVideoPlaybackState::HandleStartSeekL( TBool /*aForward*/ ) +{ + MPX_DEBUG(_L("CMPXVideoPlaybackState::HandleStartSeekL()")); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXVideoPlaybackState::HandleStopSeekL() +// ------------------------------------------------------------------------------------------------ +void CMPXVideoPlaybackState::HandleStopSeekL() +{ + MPX_DEBUG(_L("CMPXVideoPlaybackState::HandleStopSeekL()")); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXVideoPlaybackState::HandleForeground() +// ------------------------------------------------------------------------------------------------ +void CMPXVideoPlaybackState::HandleForeground() +{ + MPX_DEBUG(_L("CMPXVideoPlaybackState::HandleForeground()")); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXVideoPlaybackState::HandleBackground() +// ------------------------------------------------------------------------------------------------ +void CMPXVideoPlaybackState::HandleBackground() +{ + MPX_ENTER_EXIT(_L("CMPXVideoPlaybackState::HandleBackground()")); + + // Just pause the plackback + HandlePause(); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXVideoPlaybackState::HandleOpenComplete() +// ------------------------------------------------------------------------------------------------ +void CMPXVideoPlaybackState::HandleOpenComplete( TInt /*aError*/ ) +{ + MPX_DEBUG(_L("CMPXVideoPlaybackState::HandleOpenComplete()")); +} + + +// ------------------------------------------------------------------------------------------------ +// CMPXVideoPlaybackState::HandlePrepareComplete() +// ------------------------------------------------------------------------------------------------ +void CMPXVideoPlaybackState::HandlePrepareComplete(TInt /*aError*/) +{ + MPX_DEBUG(_L("CMPXVideoPlaybackState::HandlePrepareComplete()")); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXVideoPlaybackState::HandleLoadingStarted() +// ------------------------------------------------------------------------------------------------ +void CMPXVideoPlaybackState::HandleLoadingStarted() +{ + MPX_DEBUG(_L("CMPXVideoPlaybackState::HandleLoadingStarted()")); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXVideoPlaybackState::HandleLoadingComplete() +// ------------------------------------------------------------------------------------------------ +void CMPXVideoPlaybackState::HandleLoadingComplete(TInt /*aError*/) +{ + MPX_DEBUG(_L("CMPXVideoPlaybackState::HandleLoadingComplete()")); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXVideoPlaybackState::HandlePlaybackComplete() +// ------------------------------------------------------------------------------------------------ +// +void CMPXVideoPlaybackState::HandlePlaybackComplete( TInt aError ) +{ + MPX_ENTER_EXIT(_L("CMPXVideoPlaybackState::HandlePlaybackComplete()"), + _L("error = %d"), aError ); + + if ( aError == KErrNone ) + { + iVideoPlaybackCtlr->ChangeState( EMPXVideoStopped ); + + iVideoPlaybackCtlr->iMPXPluginObs->HandlePluginEvent( + MMPXPlaybackPluginObserver::EPPlayComplete, + 0, + aError ); + } + else + { + // + // Notify the view of an error + // + MPX_TRAPD( err, SendErrorToViewL( aError ) ); + } +} + +// ---------------------------------------------------------------------------- +// CMPXVideoPlaybackState::HandleEndOfClip() +// ---------------------------------------------------------------------------- +void CMPXVideoPlaybackState::HandleEndOfClip() +{ + MPX_ENTER_EXIT(_L("CMPXVideoPlaybackState::HandleEndOfClip()")); + + // Stop the player + iVideoPlaybackCtlr->iPlayer->Stop(); + + iVideoPlaybackCtlr->ChangeState( EMPXVideoStopped ); + + iVideoPlaybackCtlr->iMPXPluginObs->HandlePluginEvent( + MMPXPlaybackPluginObserver::EPPlayComplete, + 0, + KErrNone ); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXVideoPlaybackState::HandleVolumeChange() +// ------------------------------------------------------------------------------------------------ +void CMPXVideoPlaybackState::HandleVolumeChange() +{ + MPX_DEBUG(_L("CMPXVideoPlaybackState::HandleVolumeChange()")); + + MPX_TRAPD(err, iVideoPlaybackCtlr->SetVolumeMMFL()); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXVideoPlaybackState::HandleSetPositionL() +// ------------------------------------------------------------------------------------------------ +void CMPXVideoPlaybackState::HandleSetPositionL(TInt /*aValue*/) +{ + MPX_DEBUG(_L("CMPXVideoPlaybackState::HandleSetPositionL()")); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXVideoPlaybackState::RetrieveFileDetailsL +// ------------------------------------------------------------------------------------------------ +TInt CMPXVideoPlaybackState::RetrieveFileDetailsL( const TArray& aAttrs, + CMPXMedia* aMedia ) +{ + MPX_ENTER_EXIT(_L("CMPXVideoPlaybackState::RetrieveFileDetailsL()")); + + TUint attrG(0); // General attributes + TUint attrV(0); // Video attributes + + if (iVideoPlaybackCtlr->iPBPluginError != KErrNone) + { + aMedia->SetTObjectValueL( + TMPXAttribute( KMPXMediaVideoError ), iVideoPlaybackCtlr->iPBPluginError ); + + iVideoPlaybackCtlr->iPBPluginError = KErrNone; + } + else + { + for ( TInt i = 0 ; i < aAttrs.Count() ; ++i ) + { + TMPXAttribute attr( aAttrs[i] ); + + if ( attr.ContentId() == KMPXMediaIdGeneral ) + { + attrG |= attr.AttributeId(); + } + else if ( attr.ContentId() == KMPXMediaIdVideo ) + { + attrV |= attr.AttributeId(); + } + } + + RetrieveGeneralAttributesL( aMedia, attrG ); + RetrieveVideoAttributesL( aMedia, attrV ); + } + + return KErrNone; +} + +// ------------------------------------------------------------------------------------------------ +// CMPXVideoPlaybackState::RetrieveGeneralAttributesL +// ------------------------------------------------------------------------------------------------ +// +void CMPXVideoPlaybackState::RetrieveGeneralAttributesL( CMPXMedia* aMedia, TUint attrG ) +{ + MPX_ENTER_EXIT(_L("CMPXVideoPlaybackState::RetrieveGeneralAttributesL()")); + + // + // Clip name include path excluding scheme + // + if ( attrG & EMPXMediaGeneralUri ) + { + aMedia->SetTextValueL( + TMPXAttribute( KMPXMediaIdGeneral, EMPXMediaGeneralUri ), + *( iVideoPlaybackCtlr->iFileDetails->iClipName ) ); + } + + // + // Duration + // + if ( attrG & EMPXMediaGeneralDuration ) + { + aMedia->SetTObjectValueL( + TMPXAttribute( KMPXMediaIdGeneral, EMPXMediaGeneralDuration ), + iVideoPlaybackCtlr->iFileDetails->iDuration.Int64() / KPbMilliMultiplier); + } + + // + // Title + // + if ( ( attrG & EMPXMediaGeneralTitle ) && iVideoPlaybackCtlr->iFileDetails->iTitle ) + { + aMedia->SetTextValueL( + TMPXAttribute( KMPXMediaIdGeneral, EMPXMediaGeneralTitle ), + *( iVideoPlaybackCtlr->iFileDetails->iTitle ) ); + } + + // + // Mime Type + // + if ( ( attrG & EMPXMediaGeneralMimeType ) && iVideoPlaybackCtlr->iFileDetails->iMimeType ) + { + aMedia->SetTextValueL( + TMPXAttribute( KMPXMediaIdGeneral, EMPXMediaGeneralMimeType ), + *( iVideoPlaybackCtlr->iFileDetails->iMimeType ) ); + } +} + +// ------------------------------------------------------------------------------------------------ +// CMPXVideoPlaybackState::RetrieveVideoAttributesL +// ------------------------------------------------------------------------------------------------ +// +void CMPXVideoPlaybackState::RetrieveVideoAttributesL( CMPXMedia* aMedia, TUint attrV ) +{ + MPX_ENTER_EXIT(_L("CMPXVideoPlaybackState::RetrieveVideoAttributesL()")); + + // + // Artist + // + if ( ( attrV & KMPXMediaVideoArtist.iAttributeId ) && + ( iVideoPlaybackCtlr->iFileDetails->iArtist ) ) + { + aMedia->SetTextValueL( + TMPXAttribute( KMPXMediaVideoArtist ), + *( iVideoPlaybackCtlr->iFileDetails->iArtist ) ); + } + + // + // Partial Playback + // + if ( attrV & KMPXMediaVideoPartialPlayback.iAttributeId ) + { + aMedia->SetTObjectValueL( + TMPXAttribute( KMPXMediaVideoPartialPlayback ), + iVideoPlaybackCtlr->iFileDetails->iPartialPlayback ); + } + + // + // Audio Enabled + // + if ( attrV & KMPXMediaVideoAudioEnabled.iAttributeId ) + { + aMedia->SetTObjectValueL( + TMPXAttribute( KMPXMediaVideoAudioEnabled ), + iVideoPlaybackCtlr->iFileDetails->iAudioEnabled ); + } + + // + // Video Enabled + // + if ( attrV & KMPXMediaVideoVideoEnabled.iAttributeId ) + { + aMedia->SetTObjectValueL( + TMPXAttribute( KMPXMediaVideoVideoEnabled ), + iVideoPlaybackCtlr->iFileDetails->iVideoEnabled ); + } + + // + // Playback Mode + // + if ( attrV & KMPXMediaVideoPlaybackMode.iAttributeId ) + { + aMedia->SetTObjectValueL( + TMPXAttribute( KMPXMediaVideoPlaybackMode ), + iVideoPlaybackCtlr->iPlaybackMode->GetMode() ); + } + + // + // Seekable + // + if ( attrV & KMPXMediaVideoSeekable.iAttributeId ) + { + aMedia->SetTObjectValueL( + TMPXAttribute( KMPXMediaVideoSeekable ), + iVideoPlaybackCtlr->iFileDetails->iSeekable ); + } + + // + // Pausable + // + if ( attrV & KMPXMediaVideoPausableStream.iAttributeId ) + { + aMedia->SetTObjectValueL( + TMPXAttribute( KMPXMediaVideoPausableStream ), + iVideoPlaybackCtlr->iFileDetails->iPausableStream ); + } + + // + // Video Height + // + if ( attrV & KMPXMediaVideoHeight.iAttributeId ) + { + aMedia->SetTObjectValueL( + TMPXAttribute( KMPXMediaVideoHeight ), + iVideoPlaybackCtlr->iFileDetails->iResolutionHeight ); + } + + // + // Video Width + // + if ( attrV & KMPXMediaVideoWidth.iAttributeId ) + { + aMedia->SetTObjectValueL( + TMPXAttribute( KMPXMediaVideoWidth ), + iVideoPlaybackCtlr->iFileDetails->iResolutionWidth ); + } + + // + // TV-Out Connected + // + if ( attrV & KMPXMediaVideoTvOutConnected.iAttributeId ) + { + aMedia->SetTObjectValueL( + TMPXAttribute( KMPXMediaVideoTvOutConnected ), + iVideoPlaybackCtlr->iAccessoryMonitor->IsTvOutConnected() ); + } + + // + // TV-Out Playback Allowed + // + if ( attrV & KMPXMediaVideoTvOutPlayAllowed.iAttributeId ) + { + aMedia->SetTObjectValueL( + TMPXAttribute( KMPXMediaVideoTvOutPlayAllowed ), + iVideoPlaybackCtlr->iAccessoryMonitor->IsTvOutPlaybackAllowed() ); + } + + // + // BitRate + // + if ( attrV & KMPXMediaVideoBitRate.iAttributeId ) + { + aMedia->SetTObjectValueL( + TMPXAttribute( KMPXMediaVideoBitRate ), + iVideoPlaybackCtlr->iFileDetails->iBitRate ); + } + + // + // FourCC Code + // + if ( attrV & KMPXMediaFourCCCode.iAttributeId ) + { + aMedia->SetTObjectValueL( + TMPXAttribute( KMPXMediaFourCCCode ), + iVideoPlaybackCtlr->iFileDetails->iFourCCCode ); + } + + // + // Drm Protected + // + if ( attrV & KMPXMediaVideoDrmProtected.iAttributeId ) + { + aMedia->SetTObjectValueL( + TMPXAttribute( KMPXMediaVideoDrmProtected ), + iVideoPlaybackCtlr->iFileDetails->iDrmProtected ); + } +} + +// ------------------------------------------------------------------------------------------------ +// CMPXVideoPlaybackState::SendErrorToViewL +// ------------------------------------------------------------------------------------------------ +// +void CMPXVideoPlaybackState::SendErrorToViewL( TInt aError ) +{ + MPX_ENTER_EXIT(_L("CMPXVideoPlaybackState::SendErrorToViewL()"), + _L("aError = %d"), aError ); + + // + // create command to pass to playback plugin + // + CMPXMessage* message = CMPXMessage::NewL(); + CleanupStack::PushL( message ); + + message->SetTObjectValueL( KMPXMessageGeneralId, KMPXMediaIdVideoPlayback ); + + message->SetTObjectValueL + ( KMPXMediaVideoPlaybackCommand, EPbCmdPluginError ); + + message->SetTObjectValueL( KMPXMediaVideoError, aError ); + + iVideoPlaybackCtlr->iMPXPluginObs->HandlePlaybackMessage( message, KErrNone ); + + CleanupStack::PopAndDestroy( message ); +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPlaybackController::HandleUnexpectedError +// ------------------------------------------------------------------------------------------------- +// +void CMPXVideoPlaybackState::HandleUnexpectedError( TInt aError ) +{ + MPX_ENTER_EXIT(_L("CMPXVideoPlaybackState::HandleUnexpectedError()"), + _L("aError = %d"), aError ); + + MPX_TRAPD( err, SendErrorToViewL( aError ) ); +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPlaybackController::ResolveTimeoutError +// ------------------------------------------------------------------------------------------------- +// +void CMPXVideoPlaybackState::ResolveTimeoutError(TInt aError) +{ + MPX_ENTER_EXIT(_L("CMPXVideoPlaybackState::ResolveTimeoutError()"), + _L("aError = %d"), aError ); + + MPX_TRAPD( err, SendErrorToViewL( aError ) ); +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoPlaybackState::SetAspectRatioL +// ------------------------------------------------------------------------------------------------- +// +void CMPXVideoPlaybackState::SetAspectRatioL( CMPXCommand& aCmd, TMMFScalingType aType ) +{ + MPX_ENTER_EXIT(_L("CMPXVideoPlaybackState::SetAspectRatioL()"), + _L("aType = %d"), aType); + + TMMFMessageDestinationPckg destinationPckg( KUidInterfaceMMFControllerScalingMsg ); + + TPckgBuf scaleTypePckg( aType ); + + TInt err = + iVideoPlaybackCtlr->iPlayer->CustomCommandSync( destinationPckg, + EMMFSetScalingType, + scaleTypePckg, + KNullDesC8 ); + + if ( err ) + { + MPX_DEBUG(_L("CMPXVideoPlaybackState::SetAspectRatioL FAIL [%d]"), err); + } + else + { + iVideoPlaybackCtlr->iPlayer->RefreshFrameL(); + + } + + aCmd.SetTObjectValueL( KMPXMediaVideoAspectRatio, aType ); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXVideoPlaybackState::CommandHandleBackground +// ------------------------------------------------------------------------------------------------ +void CMPXVideoPlaybackState::CommandHandleBackground() +{ + MPX_ENTER_EXIT(_L("CMPXVideoPlaybackState::CommandHandleBackground()")); + + if ( !iVideoPlaybackCtlr->iAppInForeground || + iVideoPlaybackCtlr->IsAlarm() || + iVideoPlaybackCtlr->IsPhoneCall() || + iVideoPlaybackCtlr->IsVideoCall() ) + { + iVideoPlaybackCtlr->iAllowAutoPlay = EFalse; + } +} + +// ------------------------------------------------------------------------------------------------ +// CMPXVideoPlaybackState::CommandHandleForeground +// ------------------------------------------------------------------------------------------------ +void CMPXVideoPlaybackState::CommandHandleForeground() +{ + MPX_ENTER_EXIT(_L("CMPXVideoPlaybackState::CommandHandleForeground()")); + + if ( !iVideoPlaybackCtlr->IsActivePhoneCall() ) + { + iVideoPlaybackCtlr->iAllowAutoPlay = ETrue; + } +} + +// ------------------------------------------------------------------------------------------------ +// CMPXVideoPlaybackState::HandleCustomPause() +// ------------------------------------------------------------------------------------------------ +void CMPXVideoPlaybackState::HandleCustomPause() +{ + MPX_DEBUG(_L("CMPXVideoPlaybackState::HandleCustomPause()")); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXVideoPlaybackState::HandleCustomPlay() +// ------------------------------------------------------------------------------------------------ +void CMPXVideoPlaybackState::HandleCustomPlay() +{ + MPX_DEBUG(_L("CMPXVideoPlaybackState::HandleCustomPlay()")); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXVideoPlaybackState::RetrieveBufferingPercentage() +// ------------------------------------------------------------------------------------------------ +TInt CMPXVideoPlaybackState::RetrieveBufferingPercentage() +{ + MPX_DEBUG(_L("CMPXVideoPlaybackState::RetrieveBufferingPercentage()")); + return 100; +} + +// ************************************************************************************************* +// +// STATE SUB-CLASSES +// +// ************************************************************************************************* + + + +// ************************************************************************************************* +// +// CMPXNotInitialisedState +// +// ************************************************************************************************* + +// ------------------------------------------------------------------------------------------------ +// CMPXNotInitialisedState::NewL() +// ------------------------------------------------------------------------------------------------ +CMPXVideoPlaybackState* CMPXNotInitialisedState::NewL( + CMPXVideoPlaybackController* aVideoPlaybackCtlr ) +{ + MPX_ENTER_EXIT(_L("CMPXNotInitialisedState::NewL()")); + + CMPXNotInitialisedState* self = new( ELeave ) CMPXNotInitialisedState(); + CleanupStack::PushL( self ); + self->ConstructL(aVideoPlaybackCtlr); + CleanupStack::Pop(); + return self; +} + +// ------------------------------------------------------------------------------------------------ +// CMPXNotInitialisedState::~CMPXNotInitialisedState() +// ------------------------------------------------------------------------------------------------ +CMPXNotInitialisedState::~CMPXNotInitialisedState() +{ + MPX_DEBUG(_L("CMPXNotInitialisedState::~CMPXNotInitialisedState()")); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXNotInitialisedState::HandleVolumeChange +// ------------------------------------------------------------------------------------------------ +void CMPXNotInitialisedState::HandleVolumeChange() +{ + MPX_DEBUG(_L("CMPXNotInitialisedState::HandleVolumeChange()")); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXNotInitialisedState::RetrieveFileDetailsL +// ------------------------------------------------------------------------------------------------ +TInt CMPXNotInitialisedState::RetrieveFileDetailsL( const TArray& /*aAttrs*/, + CMPXMedia* aMedia ) +{ + MPX_DEBUG(_L("CMPXNotInitialisedState::RetrieveFileDetailsL()")); + + TInt error = KErrNone; + + if ( iVideoPlaybackCtlr->iPBPluginError != KErrNone ) + { + aMedia->SetTObjectValueL( + TMPXAttribute( KMPXMediaVideoError ), iVideoPlaybackCtlr->iPBPluginError ); + + iVideoPlaybackCtlr->iPBPluginError = KErrNone; + } + else + { + // + // Invalid call for this state + // Send HandleMedia with KErrNotReady + // + error = KErrNotReady; + } + + return error; +} + +// ------------------------------------------------------------------------------------------------ +// CMPXNotInitialisedState::HandleClose +// ------------------------------------------------------------------------------------------------ +void CMPXNotInitialisedState::HandleClose() +{ + MPX_DEBUG(_L("CMPXNotInitialisedState::HandleClose()")); + + iVideoPlaybackCtlr->CloseController(); +} + +// ------------------------------------------------------------------------------------------------- +// CMPXNotInitialisedState::SetAspectRatioL +// ------------------------------------------------------------------------------------------------- +// +void CMPXNotInitialisedState::SetAspectRatioL( CMPXCommand& /*aCmd*/, TMMFScalingType /*aType*/ ) +{ + MPX_DEBUG(_L("CMPXNotInitialisedState::SetAspectRatioL()")); +} + +// ------------------------------------------------------------------------------------------------- +// CMPXNotInitialisedState::HandleUnexpectedError +// ------------------------------------------------------------------------------------------------- +// +void CMPXNotInitialisedState::HandleUnexpectedError( TInt /*aError*/ ) +{ + MPX_ENTER_EXIT(_L("CMPXNotInitialisedState::HandleUnexpectedError()")); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXNotInitialisedState::HandleBackground() +// ------------------------------------------------------------------------------------------------ +void CMPXNotInitialisedState::HandleBackground() +{ + MPX_ENTER_EXIT(_L("CMPXNotInitialisedState::HandleBackground()")); + CommandHandleBackground(); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXNotInitialisedState::HandleForeground() +// ------------------------------------------------------------------------------------------------ +void CMPXNotInitialisedState::HandleForeground() +{ + MPX_ENTER_EXIT(_L("CMPXNotInitialisedState::HandleForeground()")); + CommandHandleForeground(); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXNotInitialisedState::HandlePlay() +// ------------------------------------------------------------------------------------------------ +void CMPXNotInitialisedState::HandlePlay() +{ + MPX_DEBUG(_L("CMPXNotInitialisedState::HandlePlay() Plugin error")); + + MPX_TRAPD( err, SendErrorToViewL( iVideoPlaybackCtlr->iPBPluginError ) ); +} + +// ************************************************************************************************* +// +// CMPXInitialisingState +// +// ************************************************************************************************* + +// ------------------------------------------------------------------------------------------------ +// CMPXInitialisingState::NewL() +// ------------------------------------------------------------------------------------------------ +CMPXVideoPlaybackState* CMPXInitialisingState::NewL( + CMPXVideoPlaybackController* aVideoPlaybackCtlr ) +{ + MPX_ENTER_EXIT(_L("CMPXInitialisingState::NewL()")); + + CMPXInitialisingState* self = new( ELeave ) CMPXInitialisingState(); + CleanupStack::PushL( self ); + self->ConstructL(aVideoPlaybackCtlr); + CleanupStack::Pop(); + return self; +} + +// ------------------------------------------------------------------------------------------------ +// CMPXInitialisingState::~CMPXInitialisingState() +// ------------------------------------------------------------------------------------------------ +CMPXInitialisingState::~CMPXInitialisingState() +{ + MPX_DEBUG(_L("CMPXInitialisingState::~CMPXInitialisingState()")); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXInitialisingState::OpenFileL +// ------------------------------------------------------------------------------------------------ +void CMPXInitialisingState::OpenFileL( const TDesC& aMediaFile ) +{ + MPX_ENTER_EXIT(_L("CMPXInitialisingState::OpenFileL()"), + _L("link = %S"), &aMediaFile ); + + iVideoPlaybackCtlr->iPBPluginError = KErrNone; + + iVideoPlaybackCtlr->iPlaybackMode->OpenFileL( aMediaFile ); +} + +// ---------------------------------------------------------------------------- +// CMPXInitialisingState::OpenFileL +// ---------------------------------------------------------------------------- +void CMPXInitialisingState::OpenFileL( const RFile& aMediaFile ) +{ + MPX_ENTER_EXIT(_L("CMPXInitialisingState::OpenFileL()")); + + // Reset the plugin error + iVideoPlaybackCtlr->iPBPluginError = KErrNone; + + iVideoPlaybackCtlr->iPlaybackMode->OpenFileL( aMediaFile ); +} + +#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API + +// ---------------------------------------------------------------------------- +// CMPXInitialisingState::OpenFile64L +// ---------------------------------------------------------------------------- +void CMPXInitialisingState::OpenFile64L( const RFile64& aMediaFile ) +{ + MPX_ENTER_EXIT(_L("CMPXInitialisingState::OpenFile64L( RFile64 )")); + + // Reset the plugin error + iVideoPlaybackCtlr->iPBPluginError = KErrNone; + + iVideoPlaybackCtlr->iPlaybackMode->OpenFile64L( aMediaFile ); +} + +#endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API + +// ------------------------------------------------------------------------------------------------ +// CMPXInitialisingState::RetrieveFileDetailsL +// ------------------------------------------------------------------------------------------------ +TInt CMPXInitialisingState::RetrieveFileDetailsL( const TArray& /*aAttrs*/, + CMPXMedia* /*aMedia*/ ) +{ + MPX_DEBUG(_L("CMPXInitialisingState::RetrieveFileDetailsL()")); + + // + // Invalid call for this state + // Send HandleMedia with KErrNotReady + // + return KErrNotReady; +} + +// ------------------------------------------------------------------------------------------------ +// CMPXInitialisingState::HandleOpenComplete() +// +// State doesn't change just send prepare to MMF +// ------------------------------------------------------------------------------------------------ +// +void CMPXInitialisingState::HandleOpenComplete( TInt aError ) +{ + MPX_ENTER_EXIT( + _L("CMPXInitialisingState::HandleOpenComplete()"), + _L("error = %d"), aError ); + + if ( aError == KErrNone ) + { + iVideoPlaybackCtlr->iPlaybackMode->HandleOpenComplete(); + + MPX_DEBUG(_L("CMPXInitialisingState::HandleOpenComplete() Sending Prepare()")); + + iVideoPlaybackCtlr->iPlayer->Prepare(); + } + else + { + // + // Transistion back to EMPXVideoNotInitialized, for pre loaded plugin + // this state will alert the view that pre loading failed + // + iVideoPlaybackCtlr->ChangeState( EMPXVideoNotInitialized ); + + // Store the error, in case of pre loaded pluging this can + // later be sent to the view + iVideoPlaybackCtlr->iPBPluginError = aError; + + // + // move the FW state to Initialized irrespective of the playback state + // This enables the FW to send initailized event to view, which in turn + // queries for the error + // + iVideoPlaybackCtlr->iMPXPluginObs->HandlePluginEvent( + MMPXPlaybackPluginObserver::EPInitialised, + 0, + KErrNone ); + } +} + +// ------------------------------------------------------------------------------------------------ +// CMPXInitialisingState::HandlePrepareComplete +// ------------------------------------------------------------------------------------------------ +void CMPXInitialisingState::HandlePrepareComplete( TInt aError ) +{ + MPX_ENTER_EXIT( _L("CMPXInitialisingState::HandlePrepareComplete()"), + _L("error = %d"), aError); + + TInt duration = 0; + + if ( aError == KErrNone || aError == KErrMMPartialPlayback ) + { + // Since PrepareComplete was successful - create post-init state instances needed + MPX_TRAPD( error, iVideoPlaybackCtlr->CreatePostInitStatesL() ); + + // + // Read in the file details + // + MPX_TRAPD( err, iVideoPlaybackCtlr->ReadFileDetailsL() ); + + if ( aError == KErrMMPartialPlayback ) + { + iVideoPlaybackCtlr->iFileDetails->iPartialPlayback = ETrue; + } + + // for streaming playback, we should know whether its LIVE or On-Demand + // at this time + // in case of live streaming, playback controller's mode would need to change + MPX_TRAPD( setModeErr, iVideoPlaybackCtlr->SetPlaybackModeL() ); + + duration = iVideoPlaybackCtlr->iFileDetails->iDuration.Int64() / KPbMilliMultiplier; + + MPX_TRAPD(setVolErr, iVideoPlaybackCtlr->SetVolumeMMFL()); + + // + // Sent a open request, transistion to EMPXVideoInitialized + // + iVideoPlaybackCtlr->ChangeState( EMPXVideoInitialized ); + + iVideoPlaybackCtlr->iMPXPluginObs-> + HandlePluginEvent( MMPXPlaybackPluginObserver::EPInitialised, duration, KErrNone ); + } + else + { + // + // Transistion back to EMPXVideoNotInitialized, for pre loaded plugin + // this state will alert the view that pre loading failed + // + iVideoPlaybackCtlr->ChangeState( EMPXVideoNotInitialized ); + + // Store the error, in case of pre loaded pluging this can + // later be sent to the view + iVideoPlaybackCtlr->iPBPluginError = aError; + + // + // move the FW state to Initialized irrespective of the playback state + // This enables the FW to send initailized event to view, which in turn + // queries for the error + // + iVideoPlaybackCtlr->iMPXPluginObs-> + HandlePluginEvent( MMPXPlaybackPluginObserver::EPInitialised, 0, KErrNone ); + } +} + +// ------------------------------------------------------------------------------------------------ +// CMPXInitialisingState::HandleVolumeChange +// ------------------------------------------------------------------------------------------------ +void CMPXInitialisingState::HandleVolumeChange() +{ + MPX_DEBUG(_L("CMPXInitialisingState::HandleVolumeChange()")); +} + +// ------------------------------------------------------------------------------------------------- +// CMPXInitialisingState::SetAspectRatioL +// ------------------------------------------------------------------------------------------------- +// +void CMPXInitialisingState::SetAspectRatioL( CMPXCommand& /*aCmd*/, TMMFScalingType /*aType*/ ) +{ + MPX_DEBUG(_L("CMPXInitialisingState::SetAspectRatioL()")); +} + +// ------------------------------------------------------------------------------------------------- +// CMPXInitialisingState::HandleUnexpectedError +// ------------------------------------------------------------------------------------------------- +// +void CMPXInitialisingState::HandleUnexpectedError( TInt /*aError*/ ) +{ + MPX_ENTER_EXIT(_L("CMPXInitialisingState::HandleUnexpectedError()")); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXInitialisingState::HandleBackground() +// ------------------------------------------------------------------------------------------------ +void CMPXInitialisingState::HandleBackground() +{ + MPX_ENTER_EXIT(_L("CMPXInitialisingState::HandleBackground()")); + CommandHandleBackground(); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXInitialisingState::HandleForeground() +// ------------------------------------------------------------------------------------------------ +void CMPXInitialisingState::HandleForeground() +{ + MPX_ENTER_EXIT(_L("CMPXInitialisingState::HandleForeground()")); + CommandHandleForeground(); +} + +// ************************************************************************************************* +// +// CMPXInitialisedState +// +// ************************************************************************************************* + +// ------------------------------------------------------------------------------------------------ +// CMPXInitialisedState::NewL() +// ------------------------------------------------------------------------------------------------ +CMPXVideoPlaybackState* CMPXInitialisedState::NewL( + CMPXVideoPlaybackController* aVideoPlaybackCtlr ) +{ + MPX_ENTER_EXIT(_L("CMPXInitialisedState::NewL()")); + + CMPXInitialisedState* self = new( ELeave ) CMPXInitialisedState(); + CleanupStack::PushL( self ); + self->ConstructL(aVideoPlaybackCtlr); + CleanupStack::Pop(); + return self; +} + +// ------------------------------------------------------------------------------------------------ +// CMPXInitialisedState::~CMPXInitialisedState() +// ------------------------------------------------------------------------------------------------ +CMPXInitialisedState::~CMPXInitialisedState() +{ + MPX_DEBUG(_L("CMPXInitialisedState::~CMPXInitialisedState()")); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXInitialisedState::HandlePlay() +// ------------------------------------------------------------------------------------------------ +void CMPXInitialisedState::HandlePlay() +{ + MPX_DEBUG(_L("CMPXInitialisedState::HandlePlay()")); + + if ( iVideoPlaybackCtlr->iPlaybackMode->CanPlayNow() ) + { + iVideoPlaybackCtlr->iForegroundPause = EFalse; + + iVideoPlaybackCtlr->iPlayer->Play(); + + iVideoPlaybackCtlr->ChangeState( EMPXVideoBuffering ); + + iVideoPlaybackCtlr->iMPXPluginObs->HandlePluginEvent( MMPXPlaybackPluginObserver::EPBufferingStarted, + 0, + KErrNone ); + } + else + { + iVideoPlaybackCtlr->iPlaybackMode->HandlePause(); + } + + iVideoPlaybackCtlr->iAllowAutoPlay = ETrue; +} + +// ------------------------------------------------------------------------------------------------ +// CMPXInitialisedState::HandleSetPositionL() +// ------------------------------------------------------------------------------------------------ +void CMPXInitialisedState::HandleSetPositionL( TInt aPosition ) +{ + MPX_ENTER_EXIT(_L("CMPXInitialisedState::HandleSetPositionL()"), + _L("position = %d"), aPosition ); + + if ( iVideoPlaybackCtlr->iFileDetails->iSeekable ) + { + TInt64 pos( aPosition ); + + pos *= KPbMilliMultiplier; + + // + // No need to set position unless it is not 0 + // + if ( pos != 0 ) + { + iVideoPlaybackCtlr->iPlayer->SetPositionL( pos ); + } + } + else + { + MPX_DEBUG(_L("CMPXInitialisedState::HandleSetPosition() FAIL - file is not seekable")); + } +} + +// ------------------------------------------------------------------------------------------------ +// CMPXInitialisedState::HandleStop() +// ------------------------------------------------------------------------------------------------ +void CMPXInitialisedState::HandleStop() +{ + MPX_ENTER_EXIT(_L("CMPXInitialisedState::HandleStop()")); + + iVideoPlaybackCtlr->iPlayer->Stop(); + + iVideoPlaybackCtlr->ChangeState( EMPXVideoStopped ); + + iVideoPlaybackCtlr->iMPXPluginObs->HandlePluginEvent( MMPXPlaybackPluginObserver::EPStopped, + 0, + KErrNone ); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXInitialisedState::HandleBackground() +// ------------------------------------------------------------------------------------------------ +void CMPXInitialisedState::HandleBackground() +{ + MPX_ENTER_EXIT(_L("CMPXInitialisedState::HandleBackground()")); + CommandHandleBackground(); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXInitialisedState::HandleForeground() +// ------------------------------------------------------------------------------------------------ +void CMPXInitialisedState::HandleForeground() +{ + MPX_ENTER_EXIT(_L("CMPXInitialisedState::HandleForeground()")); + CommandHandleForeground(); +} + +// ************************************************************************************************* +// +// CMPXPlayingState +// +// ************************************************************************************************* + +// ------------------------------------------------------------------------------------------------ +// CMPXPlayingState::NewL() +// ------------------------------------------------------------------------------------------------ +CMPXVideoPlaybackState* CMPXPlayingState::NewL( + CMPXVideoPlaybackController* aVideoPlaybackCtlr ) +{ + MPX_ENTER_EXIT(_L("CMPXPlayingState::NewL()")); + + CMPXPlayingState* self = new( ELeave ) CMPXPlayingState(); + CleanupStack::PushL( self ); + self->ConstructL(aVideoPlaybackCtlr); + CleanupStack::Pop(); + return self; +} + +// ------------------------------------------------------------------------------------------------ +// CMPXPlayingState::~CMPXPlayingState() +// ------------------------------------------------------------------------------------------------ +CMPXPlayingState::~CMPXPlayingState() +{ + MPX_DEBUG(_L("CMPXPlayingState::~CMPXPlayingState()")); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXPlayingState::HandleLoadingStarted() +// ------------------------------------------------------------------------------------------------ +void CMPXPlayingState::HandleLoadingStarted() +{ + MPX_DEBUG(_L("CMPXPlayingState::HandleLoadingStarted()")); + + TInt loadingPercentage(0); + + MPX_TRAPD( error, iVideoPlaybackCtlr->iPlayer->GetVideoLoadingProgressL( loadingPercentage ) ); + + if ( error == KErrNone ) + { + MPX_DEBUG(_L("CMPXPlayingState::HandleLoadingStarted() Loading = %d"), loadingPercentage); + + // if buffering is 100% - there is no need to transition to Buffering state + if ( loadingPercentage < 100 ) + { + iVideoPlaybackCtlr->ChangeState( EMPXVideoBuffering ); + iVideoPlaybackCtlr->iMPXPluginObs->HandlePluginEvent( + MMPXPlaybackPluginObserver::EPBufferingStarted, + 0, + KErrNone ); + } + } + else + { + MPX_TRAPD( err, SendErrorToViewL( error ) ); + } +} + +// ------------------------------------------------------------------------------------------------ +// CMPXPlayingState::HandleStop() +// ------------------------------------------------------------------------------------------------ +void CMPXPlayingState::HandleStop() +{ + MPX_ENTER_EXIT(_L("CMPXPlayingState::HandleStop()")); + + iVideoPlaybackCtlr->iPlayer->Stop(); + + iVideoPlaybackCtlr->ChangeState(EMPXVideoStopped); + + iVideoPlaybackCtlr->iMPXPluginObs->HandlePluginEvent( MMPXPlaybackPluginObserver::EPStopped, + 0, + KErrNone ); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXPlayingState::HandlePause() +// ------------------------------------------------------------------------------------------------ +void CMPXPlayingState::HandlePause() +{ + MPX_ENTER_EXIT(_L("CMPXPlayingState::HandlePause()")); + + iVideoPlaybackCtlr->iPlaybackMode->HandlePause(); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXPlayingState::HandlePlayPause() +// +// ------------------------------------------------------------------------------------------------ +void CMPXPlayingState::HandlePlayPause() +{ + MPX_DEBUG(_L("CMPXPlayingState::HandlePlayPause()")); + HandlePause(); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXPlayingState::HandleStartSeekL() +// ------------------------------------------------------------------------------------------------ +void CMPXPlayingState::HandleStartSeekL( TBool aForward ) +{ + MPX_ENTER_EXIT(_L("CMPXPlayingState::HandleStartSeekL()")); + + if ( iVideoPlaybackCtlr->iFileDetails->iSeekable ) + { + TTimeIntervalMicroSeconds pos = iVideoPlaybackCtlr->iPlayer->PositionL(); + + iVideoPlaybackCtlr->iVideoSeeker->StartSeekingL( + aForward, + GetState(), + pos.Int64(), + iVideoPlaybackCtlr->iFileDetails->iDuration.Int64() ); + + iVideoPlaybackCtlr->ChangeState( EMPXVideoSeeking ); + + iVideoPlaybackCtlr->iMPXPluginObs->HandlePluginEvent( + MMPXPlaybackPluginObserver::EPPluginSeeking, + 0, + KErrNone ); + } + else + { + MPX_DEBUG(_L("CMPXPlayingState::HandleStartSeek() FAIL - file is not seekable")); + } +} + +// ------------------------------------------------------------------------------------------------ +// CMPXPlayingState::HandleSetPositionL() +// ------------------------------------------------------------------------------------------------ +void CMPXPlayingState::HandleSetPositionL( TInt aPosition ) +{ + MPX_ENTER_EXIT(_L("CMPXPlayingState::HandleSetPositionL()"), + _L("position = %d"), aPosition ); + + if ( iVideoPlaybackCtlr->iFileDetails->iSeekable ) + { + TInt64 pos( aPosition ); + + pos *= KPbMilliMultiplier; + + // + // Helix can't handle setposition in playing state + // + iVideoPlaybackCtlr->iPlayer->PauseL(); + iVideoPlaybackCtlr->iPlayer->SetPositionL( pos ); + iVideoPlaybackCtlr->iPlayer->Play(); + } + else + { + MPX_DEBUG(_L("CMPXPlayingState::HandleSetPosition() FAIL - file is not seekable")); + } +} + +// ------------------------------------------------------------------------------------------------ +// CMPXPlayingState::ResolveTimeoutError() +// ------------------------------------------------------------------------------------------------ +void CMPXPlayingState::ResolveTimeoutError( TInt aError ) +{ + MPX_ENTER_EXIT(_L("CMPXPlayingState::ResolveTimeoutError()"), + _L("aError = %d"), aError ); + + // Timeout while playing. Show disconnect dialog. + MPX_TRAPD( err, SendErrorToViewL( KErrDisconnected ) ); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXPlayingState::HandleBackground() +// ------------------------------------------------------------------------------------------------ +void CMPXPlayingState::HandleBackground() +{ + MPX_ENTER_EXIT(_L("CMPXPlayingState::HandleBackground()")); + iVideoPlaybackCtlr->iPlaybackMode->HandleBackground(); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXPlayingState::HandleCustomPause() +// As the custom pause can only be sent for non-live playback +// There is no need to call the playback mode class to handle the custom pause +// ------------------------------------------------------------------------------------------------ +void CMPXPlayingState::HandleCustomPause() +{ + MPX_ENTER_EXIT(_L("CMPXPlayingState::HandleCustomPause()")); + + MPX_TRAPD( err, iVideoPlaybackCtlr->iPlayer->PauseL() ); + + if ( err == KErrNone ) + { + iVideoPlaybackCtlr->ChangeState( EMPXVideoPaused ); + } + else + { + TRAP_IGNORE( iVideoPlaybackCtlr->iState->SendErrorToViewL( err ) ); + } +} + +// ************************************************************************************************* +// +// CMPXPausedState +// +// ************************************************************************************************* + +// ------------------------------------------------------------------------------------------------ +// CMPXVideoPlaybackState* CMPXPausedState::NewL() +// ------------------------------------------------------------------------------------------------ +CMPXVideoPlaybackState* CMPXPausedState::NewL( CMPXVideoPlaybackController* aVideoPlaybackCtlr ) +{ + MPX_ENTER_EXIT(_L("CMPXPausedState::NewL()")); + + CMPXPausedState* self = new( ELeave ) CMPXPausedState(); + CleanupStack::PushL( self ); + self->ConstructL(aVideoPlaybackCtlr); + CleanupStack::Pop(); + return self; +} + +// ------------------------------------------------------------------------------------------------ +// CMPXPausedState::~CMPXPausedState() +// ------------------------------------------------------------------------------------------------ +CMPXPausedState::~CMPXPausedState() +{ + MPX_DEBUG(_L("CMPXPausedState::~CMPXPausedState()")); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXPausedState::HandlePlay() +// ------------------------------------------------------------------------------------------------ +void CMPXPausedState::HandlePlay() +{ + MPX_ENTER_EXIT(_L("CMPXPausedState::HandlePlay()")); + + if ( iVideoPlaybackCtlr->iPlaybackMode->CanPlayNow() ) + { + iVideoPlaybackCtlr->iForegroundPause = EFalse; + + iVideoPlaybackCtlr->iPlayer->Play(); + + iVideoPlaybackCtlr->ChangeState(EMPXVideoPlaying); + + iVideoPlaybackCtlr->iMPXPluginObs->HandlePluginEvent( MMPXPlaybackPluginObserver::EPPlaying, + 0, + KErrNone ); + } +} + +// ------------------------------------------------------------------------------------------------ +// CMPXPausedState::HandlePlayPause() +// ------------------------------------------------------------------------------------------------ +void CMPXPausedState::HandlePlayPause() +{ + MPX_DEBUG(_L("CMPXPausedState::HandlePlayPause()")); + HandlePlay(); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXPausedState::HandleSetPositionL() +// ------------------------------------------------------------------------------------------------ +void CMPXPausedState::HandleSetPositionL( TInt aPosition ) +{ + MPX_ENTER_EXIT(_L("CMPXPausedState::HandleSetPositionL()"), + _L("position = %d"), aPosition ); + + if ( iVideoPlaybackCtlr->iFileDetails->iSeekable ) + { + TInt64 pos( aPosition ); + + pos *= KPbMilliMultiplier; + + iVideoPlaybackCtlr->iPlayer->SetPositionL( pos ); + } + else + { + MPX_DEBUG(_L("CMPXPausedState::HandleSetPosition() FAIL - file is not seekable")); + } +} + +// ------------------------------------------------------------------------------------------------ +// CMPXPausedState::HandleStop() +// ------------------------------------------------------------------------------------------------ +void CMPXPausedState::HandleStop() +{ + MPX_ENTER_EXIT(_L("CMPXPausedState::HandleStop()")); + + iVideoPlaybackCtlr->iPlayer->Stop(); + + iVideoPlaybackCtlr->ChangeState(EMPXVideoStopped); + + iVideoPlaybackCtlr->iMPXPluginObs->HandlePluginEvent( MMPXPlaybackPluginObserver::EPStopped, + 0, + KErrNone ); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXPausedState::HandleStartSeekL() +// ------------------------------------------------------------------------------------------------ +void CMPXPausedState::HandleStartSeekL( TBool aForward ) +{ + MPX_ENTER_EXIT(_L("CMPXPausedState::HandleStartSeekL()")); + + if ( iVideoPlaybackCtlr->iFileDetails->iSeekable ) + { + TTimeIntervalMicroSeconds pos = iVideoPlaybackCtlr->iPlayer->PositionL(); + + iVideoPlaybackCtlr->iVideoSeeker->StartSeekingL( + aForward, + GetState(), + pos.Int64(), + iVideoPlaybackCtlr->iFileDetails->iDuration.Int64() ); + + iVideoPlaybackCtlr->ChangeState( EMPXVideoSeeking ); + + iVideoPlaybackCtlr->iMPXPluginObs->HandlePluginEvent( + MMPXPlaybackPluginObserver::EPPluginSeeking, + 0, + KErrNone ); + } + else + { + MPX_DEBUG(_L("CMPXPlayingState::HandleStartSeek() FAIL - file is not seekable")); + } +} + +// ------------------------------------------------------------------------------------------------ +// CMPXPausedState::HandleForeground() +// ------------------------------------------------------------------------------------------------ +void CMPXPausedState::HandleForeground() +{ + MPX_ENTER_EXIT(_L("CMPXPausedState::HandleForeground()"), + _L("foreground pause = %d"), iVideoPlaybackCtlr->iForegroundPause ); + + if ( iVideoPlaybackCtlr->iForegroundPause ) + { + iVideoPlaybackCtlr->iState->HandlePlay(); + } +} + +// ------------------------------------------------------------------------------------------------ +// CMPXPausedState::HandleCustomPlay() +// Handle the custom play command only when in paused state +// ------------------------------------------------------------------------------------------------ +void CMPXPausedState::HandleCustomPlay() +{ + MPX_ENTER_EXIT(_L("CMPXPausedState::HandleCustomPlay()")); + + if ( iVideoPlaybackCtlr->iPlaybackMode->CanPlayNow() ) + { + iVideoPlaybackCtlr->iForegroundPause = EFalse; + + iVideoPlaybackCtlr->iPlayer->Play(); + + iVideoPlaybackCtlr->ChangeState(EMPXVideoPlaying); + } +} + +// ************************************************************************************************* +// +// CMPXStoppedState +// +// ************************************************************************************************* + +// ------------------------------------------------------------------------------------------------ +// CMPXStoppedState::NewL() +// ------------------------------------------------------------------------------------------------ +CMPXVideoPlaybackState* CMPXStoppedState::NewL( CMPXVideoPlaybackController* aVideoPlaybackCtlr ) +{ + MPX_ENTER_EXIT(_L("CMPXStoppedState::NewL()")); + + CMPXStoppedState* self = new( ELeave ) CMPXStoppedState(); + CleanupStack::PushL( self ); + self->ConstructL(aVideoPlaybackCtlr); + CleanupStack::Pop(); + return self; +} +// ------------------------------------------------------------------------------------------------ +// CMPXStoppedState::~CMPXStoppedState() +// ------------------------------------------------------------------------------------------------ +CMPXStoppedState::~CMPXStoppedState() +{ + MPX_DEBUG(_L("CMPXStoppedState::~CMPXStoppedState()")); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXStoppedState::HandlePlay() +// ------------------------------------------------------------------------------------------------ +void CMPXStoppedState::HandlePlay() +{ + MPX_DEBUG(_L("CMPXStoppedState::HandlePlay()")); + + if ( iVideoPlaybackCtlr->iPlaybackMode->CanPlayNow() ) + { + iVideoPlaybackCtlr->iPlayer->Play(); + + iVideoPlaybackCtlr->ChangeState(EMPXVideoPlaying); + + iVideoPlaybackCtlr->iMPXPluginObs->HandlePluginEvent( MMPXPlaybackPluginObserver::EPPlaying, + 0, + KErrNone ); + } +} + +// ------------------------------------------------------------------------------------------------ +// CMPXStoppedState::HandleSetPositionL() +// ------------------------------------------------------------------------------------------------ +void CMPXStoppedState::HandleSetPositionL(TInt aPosition) +{ + MPX_ENTER_EXIT(_L("CMPXStoppedState::HandleSetPositionL()"), + _L("position = %d"), aPosition ); + + if ( iVideoPlaybackCtlr->iFileDetails->iSeekable ) + { + TInt64 pos( aPosition ); + + pos *= KPbMilliMultiplier; + + iVideoPlaybackCtlr->iPlayer->SetPositionL( pos ); + } + else + { + MPX_DEBUG(_L("CMPXStoppedState::HandleSetPosition() FAIL - file is not seekable")); + } +} + +// ------------------------------------------------------------------------------------------------ +// CMPXStoppedState::HandleClose +// ------------------------------------------------------------------------------------------------ +void CMPXStoppedState::HandleClose() +{ + MPX_ENTER_EXIT(_L("CMPXStoppedState::HandleClose()")); + + iVideoPlaybackCtlr->CloseController(); + + iVideoPlaybackCtlr->iMPXPluginObs->HandlePluginEvent( MMPXPlaybackPluginObserver::EPClosed, + 0, + KErrNone ); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXStoppedState::ResolveTimeoutError() +// ------------------------------------------------------------------------------------------------ +void CMPXStoppedState::ResolveTimeoutError( TInt aError ) +{ + MPX_ENTER_EXIT(_L("CMPXStoppedState::ResolveTimeoutError()"), + _L("aError = %d"), aError ); + + // Don't handle the error. Already in the stopped state +} + +// ************************************************************************************************* +// +// CMPXBufferingState +// +// ************************************************************************************************* + +// ------------------------------------------------------------------------------------------------ +// CMPXBufferingState::NewL() +// ------------------------------------------------------------------------------------------------ +CMPXVideoPlaybackState* CMPXBufferingState::NewL( CMPXVideoPlaybackController* aVideoPlaybackCtlr ) +{ + MPX_ENTER_EXIT(_L("CMPXBufferingState::NewL()")); + + CMPXBufferingState* self = new( ELeave ) CMPXBufferingState(); + CleanupStack::PushL( self ); + self->ConstructL(aVideoPlaybackCtlr); + CleanupStack::Pop(); + return self; +} + +// ------------------------------------------------------------------------------------------------ +// CMPXBufferingState::~CMPXBufferingState() +// ------------------------------------------------------------------------------------------------ +CMPXBufferingState::~CMPXBufferingState() +{ + MPX_DEBUG(_L("CMPXBufferingState::~CMPXBufferingState()")); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXBufferingState::HandleLoadingStarted() +// +// We transition to Buffering state after Play command is issued initially +// +// No state transitions necessary here as we are already in Buffering state +// ------------------------------------------------------------------------------------------------ +void CMPXBufferingState::HandleLoadingStarted() +{ + MPX_DEBUG(_L("CMPXBufferingState::HandleLoadingStarted()")); + + // no need to send any events - we are already in buffering state +} + +// ------------------------------------------------------------------------------------------------ +// CMPXBufferingState::HandleLoadingComplete() +// ------------------------------------------------------------------------------------------------ +void CMPXBufferingState::HandleLoadingComplete( TInt aError ) +{ + MPX_ENTER_EXIT(_L("CMPXBufferingState::HandleLoadingComplete()"), + _L("error = %d"), aError ); + + if ( aError == KErrNone ) + { + if ( iVideoPlaybackCtlr->iAppInForeground && !iVideoPlaybackCtlr->iForegroundPause ) + { + iVideoPlaybackCtlr->ChangeState( EMPXVideoPlaying ); + + iVideoPlaybackCtlr->iMPXPluginObs->HandlePluginEvent( + MMPXPlaybackPluginObserver::EPPlaying, + 0, + KErrNone ); + } + else + { + // delayed pause : + // background event was received while we were in buffering state + iVideoPlaybackCtlr->iPlaybackMode->HandlePause(); + } + } + else + { + HandleClose(); + } +} + +// ------------------------------------------------------------------------------------------------ +// CMPXBufferingState::HandleStop() +// ------------------------------------------------------------------------------------------------ +void CMPXBufferingState::HandleStop() +{ + MPX_ENTER_EXIT(_L("CMPXBufferingState::HandleStop()")); + + iVideoPlaybackCtlr->iPlayer->Stop(); + + iVideoPlaybackCtlr->ChangeState( EMPXVideoStopped ); + + iVideoPlaybackCtlr->iMPXPluginObs->HandlePluginEvent( MMPXPlaybackPluginObserver::EPStopped, + 0, + KErrNone ); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXBufferingState::HandleBackground() +// ------------------------------------------------------------------------------------------------ +void CMPXBufferingState::HandleBackground() +{ + MPX_DEBUG(_L("CMPXBufferingState::HandleBackground()")); + + // we are in buffering state and received a background event + // we cannot pause now but need to pause when buffering is complete + iVideoPlaybackCtlr->iPlaybackMode->HandleBackground(); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXBufferingState::HandleForeground() +// ------------------------------------------------------------------------------------------------ +void CMPXBufferingState::HandleForeground() +{ + MPX_DEBUG(_L("CMPXBufferingState::HandleForeground()")); + + // we are in buffering state and received a background event + // we cannot pause now but need to pause when buffering is complete +} + +// ------------------------------------------------------------------------------------------------ +// CMPXBufferingState::HandlePause() +// ------------------------------------------------------------------------------------------------ +void CMPXBufferingState::HandlePause() +{ + MPX_DEBUG(_L("CMPXBufferingState::HandlePause()")); + + // + // PDL must take action on the pause while buffering when the download is paused + // + if ( iVideoPlaybackCtlr->iPlaybackMode->IsDownloadPaused() ) + { + iVideoPlaybackCtlr->iPlaybackMode->HandlePause(); + } +} + +// ------------------------------------------------------------------------------------------------ +// CMPXBufferingState::ResolveTimeoutError() +// ------------------------------------------------------------------------------------------------ +void CMPXBufferingState::ResolveTimeoutError( TInt aError ) +{ + MPX_ENTER_EXIT(_L("CMPXBufferingState::ResolveTimeoutError()"), + _L("aError = %d"), aError ); + + // Timeout while buffering. Show buffer error. + MPX_TRAPD( err, SendErrorToViewL( KErrTimedOut ) ); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXBufferingState::RetrieveBufferingPercentage() +// ------------------------------------------------------------------------------------------------ +TInt CMPXBufferingState::RetrieveBufferingPercentage() +{ + TInt loadingProgress( 0 ); + + MPX_TRAPD( error, iVideoPlaybackCtlr->iPlayer->GetVideoLoadingProgressL( loadingProgress ) ); + MPX_DEBUG(_L("CMPXBufferingState::RetrieveBufferingPercentage(%d)"), loadingProgress); + + return loadingProgress; +} + +// ************************************************************************************************* +// +// CMPXSeekingState +// +// ************************************************************************************************* + +// ------------------------------------------------------------------------------------------------ +// CMPXSeekingState::NewL() +// ------------------------------------------------------------------------------------------------ +CMPXVideoPlaybackState* CMPXSeekingState::NewL( CMPXVideoPlaybackController* aVideoPlaybackCtlr ) +{ + MPX_ENTER_EXIT(_L("CMPXSeekingState::NewL()")); + + CMPXSeekingState* self = new( ELeave ) CMPXSeekingState(); + CleanupStack::PushL( self ); + self->ConstructL(aVideoPlaybackCtlr); + CleanupStack::Pop(); + return self; +} + +// ------------------------------------------------------------------------------------------------ +// CMPXSeekingState::~CMPXSeekingState() +// ------------------------------------------------------------------------------------------------ +CMPXSeekingState::~CMPXSeekingState() +{ + MPX_DEBUG(_L("CMPXSeekingState::~CMPXSeekingState()")); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXSeekingState::HandlePlay() +// ------------------------------------------------------------------------------------------------ +void CMPXSeekingState::HandlePlay() +{ + MPX_DEBUG(_L("CMPXSeekingState::HandlePlay()")); + + if ( iVideoPlaybackCtlr->iPlaybackMode->CanPlayNow() ) + { + iVideoPlaybackCtlr->iPlayer->Play(); + + iVideoPlaybackCtlr->ChangeState( EMPXVideoPlaying ); + + iVideoPlaybackCtlr->iMPXPluginObs->HandlePluginEvent( MMPXPlaybackPluginObserver::EPPlaying, + 0, + KErrNone ); + } + else + { + iVideoPlaybackCtlr->iPlaybackMode->HandlePause(); + } +} + +// ------------------------------------------------------------------------------------------------ +// CMPXSeekingState::HandleBackground() +// ------------------------------------------------------------------------------------------------ +void CMPXSeekingState::HandleBackground() +{ + MPX_DEBUG(_L("CMPXSeekingState::HandleBackground()")); + MPX_TRAPD( err, iVideoPlaybackCtlr->iState->HandleStopSeekL() ); + iVideoPlaybackCtlr->iPlaybackMode->HandleBackground(); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXSeekingState::HandlePause() +// ------------------------------------------------------------------------------------------------ +void CMPXSeekingState::HandlePause() +{ + MPX_DEBUG(_L("CMPXSeekingState::HandlePause()")); + iVideoPlaybackCtlr->iPlaybackMode->HandlePause(); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXSeekingState::HandleStopSeekL() +// ------------------------------------------------------------------------------------------------ +void CMPXSeekingState::HandleStopSeekL() +{ + MPX_ENTER_EXIT(_L("CMPXSeekingState::HandleStopSeekL()")); + + iVideoPlaybackCtlr->iVideoSeeker->StopSeekingL(); +} + +// ------------------------------------------------------------------------------------------------ +// CMPXSeekingState::HandleSetPositionL() +// ------------------------------------------------------------------------------------------------ +void CMPXSeekingState::HandleSetPositionL( TInt aPosition ) +{ + MPX_ENTER_EXIT(_L("CMPXSeekingState::HandleSetPositionL()"), + _L("position = %d"), aPosition ); + + if ( iVideoPlaybackCtlr->iFileDetails->iSeekable ) + { + TInt64 pos( aPosition ); + + pos *= KPbMilliMultiplier; + + iVideoPlaybackCtlr->iPlayer->SetPositionL( pos ); + } + else + { + MPX_DEBUG(_L("CMPXSeekingState::HandleSetPosition() FAIL - file is not seekable")); + } +} + +// ------------------------------------------------------------------------------------------------ +// CMPXSeekingState::HandleStop() +// ------------------------------------------------------------------------------------------------ +void CMPXSeekingState::HandleStop() +{ + MPX_ENTER_EXIT(_L("CMPXSeekingState::HandleStop()")); + + iVideoPlaybackCtlr->iPlayer->Stop(); + + iVideoPlaybackCtlr->ChangeState( EMPXVideoStopped ); + + iVideoPlaybackCtlr->iMPXPluginObs->HandlePluginEvent( MMPXPlaybackPluginObserver::EPStopped, + 0, + KErrNone ); +} + +// End of file