--- /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 <mpxcommandgeneraldefs.h>
+#include <mpxmessagegeneraldefs.h>
+
+#include "mpxvideoplaybackcontroller.h"
+#include "mpxvideoplaybackstate.h"
+#include <mpxvideoplaybackdefs.h>
+#include <mpxplaybackpluginobserver.h>
+#include <mpxmediageneraldefs.h>
+#include <mpxcenrepwatcher.h>
+
+#include <mmf/server/mmffile.h>
+#include <mmf/common/mmferrors.h>
+
+#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<TMPXAttribute>& 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<TInt>(
+ 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<TInt>(
+ 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<TInt>(
+ TMPXAttribute( KMPXMediaVideoPartialPlayback ),
+ iVideoPlaybackCtlr->iFileDetails->iPartialPlayback );
+ }
+
+ //
+ // Audio Enabled
+ //
+ if ( attrV & KMPXMediaVideoAudioEnabled.iAttributeId )
+ {
+ aMedia->SetTObjectValueL<TInt>(
+ TMPXAttribute( KMPXMediaVideoAudioEnabled ),
+ iVideoPlaybackCtlr->iFileDetails->iAudioEnabled );
+ }
+
+ //
+ // Video Enabled
+ //
+ if ( attrV & KMPXMediaVideoVideoEnabled.iAttributeId )
+ {
+ aMedia->SetTObjectValueL<TInt>(
+ TMPXAttribute( KMPXMediaVideoVideoEnabled ),
+ iVideoPlaybackCtlr->iFileDetails->iVideoEnabled );
+ }
+
+ //
+ // Playback Mode
+ //
+ if ( attrV & KMPXMediaVideoPlaybackMode.iAttributeId )
+ {
+ aMedia->SetTObjectValueL<TInt>(
+ TMPXAttribute( KMPXMediaVideoPlaybackMode ),
+ iVideoPlaybackCtlr->iPlaybackMode->GetMode() );
+ }
+
+ //
+ // Seekable
+ //
+ if ( attrV & KMPXMediaVideoSeekable.iAttributeId )
+ {
+ aMedia->SetTObjectValueL<TBool>(
+ TMPXAttribute( KMPXMediaVideoSeekable ),
+ iVideoPlaybackCtlr->iFileDetails->iSeekable );
+ }
+
+ //
+ // Pausable
+ //
+ if ( attrV & KMPXMediaVideoPausableStream.iAttributeId )
+ {
+ aMedia->SetTObjectValueL<TBool>(
+ TMPXAttribute( KMPXMediaVideoPausableStream ),
+ iVideoPlaybackCtlr->iFileDetails->iPausableStream );
+ }
+
+ //
+ // Video Height
+ //
+ if ( attrV & KMPXMediaVideoHeight.iAttributeId )
+ {
+ aMedia->SetTObjectValueL<TInt>(
+ TMPXAttribute( KMPXMediaVideoHeight ),
+ iVideoPlaybackCtlr->iFileDetails->iResolutionHeight );
+ }
+
+ //
+ // Video Width
+ //
+ if ( attrV & KMPXMediaVideoWidth.iAttributeId )
+ {
+ aMedia->SetTObjectValueL<TInt>(
+ TMPXAttribute( KMPXMediaVideoWidth ),
+ iVideoPlaybackCtlr->iFileDetails->iResolutionWidth );
+ }
+
+ //
+ // TV-Out Connected
+ //
+ if ( attrV & KMPXMediaVideoTvOutConnected.iAttributeId )
+ {
+ aMedia->SetTObjectValueL<TInt>(
+ TMPXAttribute( KMPXMediaVideoTvOutConnected ),
+ iVideoPlaybackCtlr->iAccessoryMonitor->IsTvOutConnected() );
+ }
+
+ //
+ // TV-Out Playback Allowed
+ //
+ if ( attrV & KMPXMediaVideoTvOutPlayAllowed.iAttributeId )
+ {
+ aMedia->SetTObjectValueL<TInt>(
+ TMPXAttribute( KMPXMediaVideoTvOutPlayAllowed ),
+ iVideoPlaybackCtlr->iAccessoryMonitor->IsTvOutPlaybackAllowed() );
+ }
+
+ //
+ // BitRate
+ //
+ if ( attrV & KMPXMediaVideoBitRate.iAttributeId )
+ {
+ aMedia->SetTObjectValueL<TInt>(
+ TMPXAttribute( KMPXMediaVideoBitRate ),
+ iVideoPlaybackCtlr->iFileDetails->iBitRate );
+ }
+
+ //
+ // FourCC Code
+ //
+ if ( attrV & KMPXMediaFourCCCode.iAttributeId )
+ {
+ aMedia->SetTObjectValueL<TUint32>(
+ TMPXAttribute( KMPXMediaFourCCCode ),
+ iVideoPlaybackCtlr->iFileDetails->iFourCCCode );
+ }
+
+ //
+ // Drm Protected
+ //
+ if ( attrV & KMPXMediaVideoDrmProtected.iAttributeId )
+ {
+ aMedia->SetTObjectValueL<TInt>(
+ 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<TMPXMessageId>( KMPXMessageGeneralId, KMPXMediaIdVideoPlayback );
+
+ message->SetTObjectValueL<TMPXVideoPlaybackCommand>
+ ( KMPXMediaVideoPlaybackCommand, EPbCmdPluginError );
+
+ message->SetTObjectValueL<TInt>( 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<TInt> 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<TInt>( 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<TMPXAttribute>& /*aAttrs*/,
+ CMPXMedia* aMedia )
+{
+ MPX_DEBUG(_L("CMPXNotInitialisedState::RetrieveFileDetailsL()"));
+
+ TInt error = KErrNone;
+
+ if ( iVideoPlaybackCtlr->iPBPluginError != KErrNone )
+ {
+ aMedia->SetTObjectValueL<TInt>(
+ 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<TMPXAttribute>& /*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