FCL/sf/app/videoplayer: comparison videoplayback/videohelix/src/mpxvideoplaybackcontroller.cpp

equal deleted inserted replaced

-:3738fe97f027
+:8aed59de29f9
 *
 * Description:  This class plays local video file
 *
 */
-// Version : %version: 50 %
+// Version : %version: 56 %
 //
 //  INCLUDE FILES
 //
 #include <mmf/common/mmferrors.h>
 #include <e32std.h>
 #include <devsoundif.h>
 #include <avkondomainpskeys.h>
 #include <hwrmlight.h>
 #include <centralrepository.h>  // For display timeout setting
 #include <hwrmlightdomaincrkeys.h>
 #include "mpxvideoregion.h"
 #include "mpxvideoplaybackcontroller.h"
 _LIT( KAbstract, "Abstract" );
 _LIT( KLocation, "Location" );
 _LIT( KRightCopy, "Copyright" );
 _LIT( KLanguage, "Language" );
 _LIT( KKeywords, "Keywords" );
+_LIT( KCreated, "CreationTime" );
+_LIT( KLastModified, "ModificationTime" );
 // ============================ MEMBER FUNCTIONS ===================================================
 //  ------------------------------------------------------------------------------------------------
 iPlayer = CMpxVideoPlayerUtility::NewL( this );
 iBackLightTimer = CPeriodic::NewL( CActive::EPriorityStandard );
 iDrmHelper = CMpxVideoDrmHelper::NewL();
 iSavedPosition = 0;
 }
 //  ----------------------------------------------------------------------------
 //  CMPXVideoPlaybackController::CloseController()
 //  ------------------------------------------------------------------------------------------------
 //
 void CMPXVideoPlaybackController::OpenFileL( const TDesC& aMediaFile,
 RFile& aFile,
 TInt aPosition,
 TInt aAccessPointId )
 {
 MPX_ENTER_EXIT(_L("CMPXVideoPlaybackController::OpenFileL()"),
 _L("file = %S"), &aMediaFile );
 TBool fileExists = EFalse;
 DetermineMediaTypeL();
 SetPlaybackModeL();
 iSavedPosition = aPosition;
 //
 //  Create accessory monitor to search for TV-Out events
 //
 if ( ! iAccessoryMonitor )
 {
 if ( iPlayer )
 {
 delete iPlayer;
 iPlayer = NULL;
 }
 if ( iUserActivityTimer )
 {
 iUserActivityTimer->Cancel();
 delete iUserActivityTimer;
 iUserActivityTimer = NULL;
 }
 ReleaseLights();
 CancelDisplayTimer();
 #ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
 if ( iFileHandle64.SubSessionHandle() )
 }
 case EPbCmdUpdateSeekable:
 {
 iSeekable = aCmd.ValueTObjectL<TBool>(KMPXMediaGeneralExtVideoSeekable);
-if( iFileDetails )
+if ( iFileDetails )
 {
 iFileDetails->iSeekable &= iSeekable;
 }
 break;
 }
 aCmd.SetTObjectValueL<TInt>( KMPXMediaVideoBufferingPercentage,
 bufferingPercentage );
-break;
-}
-case EPbCmdSurfaceRemoved:
-{
-iPlayer->SurfaceRemovedFromView();
-break;
-}
-default:
-{
 break;
 }
 }
 }
 }
 switch ( aChangeToState )
 {
 case EMPXVideoPlaying:
 {
 iState = iPlayingState;
 //
 //  If clip is audio only, stop the backlight timer and break switch
 //  If clip has audio and video, proceed to the next case which will
 //  start the backlight timer if needed
 //
 }
 else
 {
 CancelLightsControl();
 }
 break;
 }
 case EMPXVideoPaused:
 {
 iState = iPausedState;
 CleanupStack::PushL( metaData );
 if ( ! metaData->Name().CompareF( KSeekable ) )
 {
-if ( ! metaData->Value().CompareF( KTrue ) )
+if ( ! metaData->Value().CompareF( KFalse ) )
 {
-iFileDetails->iSeekable = ETrue;
+iFileDetails->iSeekable = EFalse;
 }
 }
 else if ( ! metaData->Name().CompareF( KLiveStream ) )
 {
 if ( ! metaData->Value().CompareF( KTrue ) )
 iFileDetails->iLanguage = metaData->Value().AllocL();
 }
 else if ( !metaData->Name().CompareF( KKeywords ) )
 {
 iFileDetails->iKeywords = metaData->Value().AllocL();
+}
+else if ( !metaData->Name().CompareF( KCreated ) )
+{
+TLex lex( metaData->Value() );
+lex.Val( iFileDetails->iCreationTime );
+}
+else if ( !metaData->Name().CompareF( KLastModified ) )
+{
+TLex lex( metaData->Value() );
+lex.Val( iFileDetails->iModificationTime );
 }
 CleanupStack::PopAndDestroy( metaData );
 }
 MPX_DEBUG(_L("CMPXVideoPlaybackController::IsAlarm(%d)"), alarm);
 return alarm;
 }
-// -----------------------------------------------------------------------------
+// -------------------------------------------------------------------------------------------------
-// CMPXVideoPlaybackController::IsKeyLocked
+//   CMPXVideoPlaybackController::IsKeyLocked
-// -----------------------------------------------------------------------------
+// -------------------------------------------------------------------------------------------------
 //
 TBool CMPXVideoPlaybackController::IsKeyLocked()
 {
 TBool keylock( EFalse );
 RProperty::Get( KPSUidAvkonDomain, KAknKeyguardStatus, keylock );
 MPX_DEBUG(_L("CMPXVideoPlaybackController::IsKeyLocked(%d)"), keylock);
 return keylock;
 }
+// -------------------------------------------------------------------------------------------------
+//   CMPXVideoPlaybackController::SendTvOutEventL
+// -------------------------------------------------------------------------------------------------
+//
+void CMPXVideoPlaybackController::SendTvOutEventL( TBool aConnected, TBool aPlaybackAllowed )
+{
+MPX_ENTER_EXIT(_L("CMPXVideoPlaybackController::SendTvOutEventL()"));
+//
+//  Send notice to the playback view with TV-Out connection status
+//  and TV-Out playback allowed flag
+//
+CMPXMessage* message = CMPXMessage::NewL();
+CleanupStack::PushL( message );
+message->SetTObjectValueL<TMPXMessageId>( KMPXMessageGeneralId, KMPXMediaIdVideoPlayback );
+message->SetTObjectValueL<TMPXVideoPlaybackCommand>
+( KMPXMediaVideoPlaybackCommand, EPbCmdTvOutEvent );
+message->SetTObjectValueL<TInt>( KMPXMediaVideoTvOutConnected, aConnected );
+message->SetTObjectValueL<TInt>( KMPXMediaVideoTvOutPlayAllowed, aPlaybackAllowed );
+iMPXPluginObs->HandlePlaybackMessage( message, KErrNone );
+CleanupStack::PopAndDestroy( message );
+}
+// -------------------------------------------------------------------------------------------------
+//   CMPXVideoPlaybackController::SendHideControlsEventL
+// -------------------------------------------------------------------------------------------------
+//
+void CMPXVideoPlaybackController::SendHideControlsEventL()
+{
+MPX_ENTER_EXIT(_L("CMPXVideoPlaybackController::SendHideControlsEventL()"));
+//
+//  Send notice to the playback view to hide the controls
+//  when key lock
+//
+CMPXMessage* message = CMPXMessage::NewL();
+CleanupStack::PushL( message );
+message->SetTObjectValueL<TMPXMessageId>( KMPXMessageGeneralId, KMPXMediaIdVideoPlayback );
+message->SetTObjectValueL<TMPXVideoPlaybackCommand>
+( KMPXMediaVideoPlaybackCommand, EPbCmdHideControls );
+iMPXPluginObs->HandlePlaybackMessage( message, KErrNone );
+CleanupStack::PopAndDestroy( message );
+}
 //  ------------------------------------------------------------------------------------------------
 //    CMPXVideoPlaybackController::HandleTvOutEventL()
 //  ------------------------------------------------------------------------------------------------
 //
 void CMPXVideoPlaybackController::HandleTvOutEventL( TBool aConnected )
 {
 MPX_ENTER_EXIT( _L("CMPXVideoPlaybackController::HandleTvOutEventL()"),
 _L("aConnected = %d"), aConnected );
-TBool playbackAllowed = ETrue;
+TBool playbackAllowed = iAccessoryMonitor->IsTvOutPlaybackAllowed();
+SendTvOutEventL( aConnected, playbackAllowed );
+//
+//  Check playback status of clip with new Tv-Out status
+//
 if ( aConnected )
 {
 //
 //  TV-Out accessory connected
 //
-if ( ! iAccessoryMonitor->IsTvOutPlaybackAllowed() )
+if ( ! playbackAllowed )
 {
 //
 //  Clip has DRM protection and TV-Out is connected
 //  Pause playback and display info note
 //
 DoHandleCommandL( EPbCmdPause );
-playbackAllowed = EFalse;
 iState->SendErrorToViewL( KMPXVideoTvOutPlaybackNotAllowed );
 }
 else
 {
 // If lights are being controlled enable display timer so that screen backlight will be turned
 // of after timeout.
 if ( iBackLightTimer->IsActive() )
 {
 RestartDisplayTimer();
 }
 }
 }
 else
 {
 // TV out disconnected
 CancelDisplayTimer();
 // Ensure that lights are on after this
 ReleaseLights();
 // Pause playback since TV-Out accessory has been disconnected.
 DoHandleCommandL( EPbCmdPause );
 }
-//
-//  Send notice to the playback view with TV-Out connection status
-//  and TV-Out playback allowed flag
-//
-CMPXMessage* message = CMPXMessage::NewL();
-CleanupStack::PushL( message );
-message->SetTObjectValueL<TMPXMessageId>( KMPXMessageGeneralId, KMPXMediaIdVideoPlayback );
-message->SetTObjectValueL<TMPXVideoPlaybackCommand>
-( KMPXMediaVideoPlaybackCommand, EPbCmdTvOutEvent );
-message->SetTObjectValueL<TInt>( KMPXMediaVideoTvOutConnected, aConnected );
-message->SetTObjectValueL<TInt>( KMPXMediaVideoTvOutPlayAllowed, playbackAllowed );
-iMPXPluginObs->HandlePlaybackMessage( message, KErrNone );
-CleanupStack::PopAndDestroy( message );
 }
 //  ------------------------------------------------------------------------------------------------
 //    CMPXVideoPlaybackController::CancelBackLightTimer
 //  ------------------------------------------------------------------------------------------------
 if ( iBackLightTimer->IsActive() )
 {
 iBackLightTimer->Cancel();
 }
 }
 //  ------------------------------------------------------------------------------------------------
 //    CMPXVideoPlaybackState::StartBackLightTimer
 //  ------------------------------------------------------------------------------------------------
 iBackLightTimer->Start(
 0,
 KMPXBackLightTimeOut,
 TCallBack( CMPXVideoPlaybackController::HandleBackLightTimeout, this ));
 }
 }
 // -------------------------------------------------------------------------------------------------
 // Handle back light timer timeout callback
 // -------------------------------------------------------------------------------------------------
 // -------------------------------------------------------------------------------------------------
 //
 void CMPXVideoPlaybackController::DoHandleBackLightTimeout()
 {
 MPX_ENTER_EXIT(_L("CMPXVideoPlaybackController::DoHandleBackLightTimeout()"));
 TBool tvOutConnected( EFalse );
 if ( iAccessoryMonitor )
 {
 tvOutConnected = iAccessoryMonitor->IsTvOutConnected();
 }
 // User activity timer runs always when TV-out is connected
 // it keeps resetting display timer and keeps lights on whenever there is user activity
 if ( tvOutConnected )
 {
 MPX_DEBUG ( _L("CMPXVideoPlaybackController::DoHandleBackLightTimeout() inactivity time = %d"), User::InactivityTime().Int() );
 // Cancel activity timer. Otherwise resetting inactivity time would fire user activity detection
 CancelUserActivityTimer();
 }
 User::ResetInactivityTime();
 if ( tvOutConnected )
 {
 // Restart user activity timer. It must be running between backlight timer intervals so that backlight
 // can be turned on if user activity is detected.
 RestartUserActivityTimer();
 void CMPXVideoPlaybackController::StartLightsControl()
 {
 MPX_ENTER_EXIT(_L("CMPXVideoPlaybackController::StartLightsControl()"));
 StartBackLightTimer();
 if (iAccessoryMonitor )
 {
 if ( iAccessoryMonitor->IsTvOutConnected() )
 {
 RestartDisplayTimer();
 // -----------------------------------------------------------------------------
 //
 void CMPXVideoPlaybackController::CancelLightsControl()
 {
 MPX_ENTER_EXIT(_L("CMPXVideoPlaybackController::CancelLightsControl()"));
 // This is called whenever there is no need to keep screensaver of anymore
 // This means that also displaytimer and activity monitoring can be stopped.
 // This method is not correct place for these calls
 CancelBackLightTimer();
 CancelUserActivityTimer();
 CancelDisplayTimer();
 // Ensure that lights are on
 EnableDisplayBacklight();
-	// Release lights if releserved
+// Release lights if releserved
 ReleaseLights();
 }
 // -----------------------------------------------------------------------------
 // CMPXVideoPlaybackController::InitDisplayTimerL
 // -----------------------------------------------------------------------------
 //
 TTimeIntervalMicroSeconds32 CMPXVideoPlaybackController::InitDisplayTimerL()
 {
 MPX_ENTER_EXIT(_L("CMPXVideoPlaybackController::InitDisplayTimerL()"));
 if ( !iDisplayTimer )
 {
 iDisplayTimer = CPeriodic::NewL( CPeriodic::EPriorityStandard );
 MPX_DEBUG(_L("CMPXVideoPlaybackController::InitDisplayTimerL() - created") );
+}
-}
 if ( iDisplayTimerTimeout.Int() == 0 )
 {
 // Get the display light time-out value from CenRep
 CRepository* repository = CRepository::NewLC( KCRUidLightSettings  );
 // What's the timeout value (in seconds ) for the display light?
 TInt displayTimeOut ( 0 );
 repository->Get( KDisplayLightsTimeout, displayTimeOut );
 if ( ( displayTimeOut * KMPXMicroSecondsInASecond ) > KMaxTInt )
 {
 iDisplayTimerTimeout = KMaxTInt;
 }
 else
 {
 iDisplayTimerTimeout = displayTimeOut * KMPXMicroSecondsInASecond;
 }
 CleanupStack::PopAndDestroy( repository );
 }
 MPX_DEBUG( _L("CMPXVideoPlaybackController::InitDisplayTimerL Timeout(%d)"), iDisplayTimerTimeout.Int() );
 // Convert the timeout value to microseconds
 return iDisplayTimerTimeout;
 }
 // -----------------------------------------------------------------------------
 // CMPXVideoPlaybackController::RestartDisplayTimer
 // -----------------------------------------------------------------------------
 TTimeIntervalMicroSeconds32 displayTimeOut(0);
 // Leave system to safe state if following leaves. Lights stay on
 MPX_TRAPD(err, displayTimeOut=InitDisplayTimerL(); )
 if ( err == KErrNone )
 {
 // check if the display timer is running and cancel it
 if ( iDisplayTimer->IsActive() )
 {
 iDisplayTimer->Cancel();
 }
 MPX_DEBUG( _L("CMPXVideoPlaybackController::RestartDisplayTimer() restarting displayTimer to=%d ms"), displayTimeOut.Int() );
 iDisplayTimer->Start( displayTimeOut, displayTimeOut,
 TCallBack( CMPXVideoPlaybackController::HandleDisplayTimeout, this ) );
 }
 }
 // -----------------------------------------------------------------------------
 // CMPXVideoPlaybackController::CancelDisplayTimer
 // -----------------------------------------------------------------------------
 //
 void CMPXVideoPlaybackController::CancelDisplayTimer()
 {
 MPX_ENTER_EXIT(_L("CMPXVideoPlaybackController::CancelDisplayTimer"));
 if ( iDisplayTimer )
 {
 if ( iDisplayTimer->IsActive() )
 {
 iDisplayTimer->Cancel();
 //  ------------------------------------------------------------------------------------------------
 //  CMPXVideoPlaybackController::EnableDisplayBacklight
 //  ------------------------------------------------------------------------------------------------
 //
 void CMPXVideoPlaybackController::EnableDisplayBacklight()
 {
 MPX_ENTER_EXIT(_L("CMPXVideoPlaybackController::EnableDisplayBacklight()"));
 // ELightStatusUnknown - We are not controlling lights and we don't care about lights
 // ELightOn            - Ligths are certainly on
 MPX_DEBUG(_L("CMPXVideoPlaybackController::EnableDisplayBacklight() iLightStatus=%d"), iLightStatus );
 // We are responsible of turning lights on only if we have switched them off.
 if ( iLightStatus == CHWRMLight::ELightOff )
 {
 MPX_TRAPD( err,
 {
 // Following GetLightsL() call will not leave.
 // This call should not result to creation of CHWRMLight in this case
 // because CHWRMLight was created when lights were turned off.
 CHWRMLight* lights= GetLightsL();
 if ( lights->LightStatus(CHWRMLight::EPrimaryDisplay) == CHWRMLight::ELightOff )
 {
 MPX_DEBUG(_L("CMPXVideoPlaybackController::EnableDisplayBacklight() enabling") );
 lights->LightOnL( CHWRMLight::EPrimaryDisplay, 0  );
 iLightStatus = CHWRMLight::ELightOn;
 }
 } );
+}
-}
 }
 //  ------------------------------------------------------------------------------------------------
 //  CMPXVideoPlaybackController::DisableDisplayBacklight
 //  ------------------------------------------------------------------------------------------------
 //
 void CMPXVideoPlaybackController::DisableDisplayBacklight()
 {
 MPX_ENTER_EXIT(_L("CMPXVideoPlaybackController::DisableDisplayBacklight()"));
 // No major harm done if following block leaves. Lights are left on
 MPX_TRAPD( err,
 {
 CHWRMLight* lights = GetLightsL();
 if ( lights->LightStatus(CHWRMLight::EPrimaryDisplay) == CHWRMLight::ELightOn )
 {
 MPX_DEBUG(_L("CMPXVideoPlaybackController::DisableDisplayBacklight() disabling") );
 lights->LightOffL( CHWRMLight::EPrimaryDisplay, 0  );
 iLightStatus = CHWRMLight::ELightOff;
 }
 } );
 }
 //  ------------------------------------------------------------------------------------------------
 //  CMPXVideoPlaybackController::InitUserActivityTimer
 //  ------------------------------------------------------------------------------------------------
 //
 void CMPXVideoPlaybackController::InitUserActivityTimerL()
 {
 MPX_ENTER_EXIT(_L("CMPXVideoPlaybackController::InitUserActivityTimerL()"));
 iUserActivityTimer = CPeriodic::NewL( CActive::EPriorityStandard);
 // This timer will not run to the end. Timer will be canceled and reset at backlight timeout.
 iUserActivityTimer->Start(
 0,
 KMPXInactivityTimeout,
 TCallBack( CMPXVideoPlaybackController::HandleUserActivityTimeout, this ));
 }
 //  ------------------------------------------------------------------------------------------------
 //  CMPXVideoPlaybackController::RestartUserActivityTimer
 //  ------------------------------------------------------------------------------------------------
 //
 void CMPXVideoPlaybackController::RestartUserActivityTimer()
 {
 MPX_ENTER_EXIT(_L("CMPXVideoPlaybackController::RestartUserActivityTimer()"));
 if ( !iUserActivityTimer )
 {
 // This is first call. Create and initialize timer
 MPX_TRAPD( err,
 {
 InitUserActivityTimerL();
 } );
-// If user activity timer creation fails we can't detect user activity and
-// get lights back on when user taps screen.
+// If user activity timer creation fails we can't detect user activity and
+// get lights back on when user taps screen.
 // Leave lights on.
 if ( err != KErrNone )
 {
 EnableDisplayBacklight();
 }
 }
 if ( iUserActivityTimer )
 {
 if ( iUserActivityTimer->IsActive() )
 {
 iUserActivityTimer->Cancel();
 }
 // Not interested about inactivity callback, only activity
 // If CPeriodic::Inactivity is started with argument 0
 // timer will fire when system's user inactivity timer resets.
 iUserActivityTimer->Inactivity( 0 );
 }
 }
 //  ------------------------------------------------------------------------------------------------
 //  CMPXVideoPlaybackController::CancelUserActivityTimer
 //  ------------------------------------------------------------------------------------------------
 //
 void CMPXVideoPlaybackController::CancelUserActivityTimer()
 {
 MPX_ENTER_EXIT(_L("CMPXVideoPlaybackController::CancelUserActivityTimer()"));
 if  ( iUserActivityTimer )
 {
 if ( iUserActivityTimer->IsActive() )
 {
 iUserActivityTimer->Cancel();
 }
 }
 }
 //  ------------------------------------------------------------------------------------------------
 //  CMPXVideoPlaybackController::HandleUserActivityTimeout
 //  ------------------------------------------------------------------------------------------------
 //
 TInt CMPXVideoPlaybackController::HandleUserActivityTimeout( TAny* aPtr )
 {
 MPX_ENTER_EXIT(_L("CMPXVideoPlaybackController::HandleUserActivityTimeout()"));
 static_cast<CMPXVideoPlaybackController*>(aPtr)->DoHandleUserActivityTimeout();
 return KErrNone;
 }
 //  ------------------------------------------------------------------------------------------------
 //  CMPXVideoPlaybackController::DoHandleUserActivityTimeout
 //  ------------------------------------------------------------------------------------------------
 //
 void CMPXVideoPlaybackController::DoHandleUserActivityTimeout()
 {
 MPX_ENTER_EXIT(_L("CMPXVideoPlaybackController::DoHandleUserActivityTimeout()"));
 // Act only once for detected activity.
 if ( iUserActivityTimer->IsActive() )
 {
 iUserActivityTimer->Cancel();
 }
 // iUserActivityTimer runs when TV-out is connected and playback with video is going on
 // This timer fires in two situations.
 // a) Lights are off and user activity is detected - Turn lights on and restart display timer
 // b) Lights are on and user activity is detected - restart display timer to prevent lights go off
 EnableDisplayBacklight();
 // Start counting down to next lights off
 RestartDisplayTimer();
 }
 //  ------------------------------------------------------------------------------------------------
 //  ------------------------------------------------------------------------------------------------
 //
 CHWRMLight* CMPXVideoPlaybackController::GetLightsL()
 {
 MPX_ENTER_EXIT(_L("CMPXVideoPlaybackController::GetLightsL()"));
 if ( !iLight )
 {
 MPX_DEBUG( _L("CMPXVideoPlaybackController::GetLightsL() - creating") );
 iLight = CHWRMLight::NewL();
 }
 return iLight;
 //  ------------------------------------------------------------------------------------------------
 //
 void CMPXVideoPlaybackController::ReleaseLights()
 {
 MPX_ENTER_EXIT(_L("CMPXVideoPlaybackController::ReleaseLights()"));
 if ( iLight )
 {
 // If iLights was created when ReleaseLights was called then TV out must be connected and lights may be off.
 // This call ensures that lights are on again.
 EnableDisplayBacklight();
 MPX_DEBUG( _L("CMPXVideoPlaybackController::ReleaseLights() - deleting") );
 delete iLight;
 iLight = NULL;
 }
 }
 if ( iFileHandle64.SubSessionHandle() )
 {
 iFileHandle64.Close();
 }
 #endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
 // reset to True
 iSeekable = ETrue;
 //
 //  Needs to be last thing destroyed since PDL requires the
 }
 DetermineMediaTypeL();
 SetPlaybackModeL();
 iSavedPosition = aPosition;
 //
 //  Create accessory monitor to search for TV-Out events
 //
 if ( ! iAccessoryMonitor )
 {

changeset 36	8aed59de29f9
parent 35	3738fe97f027
child 37	4eb2df7f7cbe