FCL/sf/app/videoplayer: comparison videoplayback/hbvideoplaybackview/controlsrc/mpxvideoplaybackcontrolscontroller.cpp

equal deleted inserted replaced

-:c48470be1ba7
+:adbe7d5ba2f5
 *
 * Description:  Implementation of MPXVideoPlaybackControlsController
 *
 */
-// Version : %version: da1mmcf#40 %
+// Version : %version: da1mmcf#41 %
 // INCLUDE FILES
 #include <coecntrl.h>
 #include <hbvolumesliderpopup.h>
 #include <hbtransparentwindow.h>
 #include <hbiconanimationmanager.h>
 #include <shareui.h>
 #include <hbinstance.h>
+#include <hbtapgesture.h>
+#include <hbpangesture.h>
 #include "mpxvideoviewwrapper.h"
 #include "hbvideobaseplaybackview.h"
 #include "mpxvideoplaybackcontrolbar.h"
 #include "mpxvideoplaybackcontrolpolicy.h"
 mOrientation = hbInstance->allMainWindows()[0]->orientation();
 bool ok = connect( hbInstance->allMainWindows()[0], SIGNAL( orientationChanged( Qt::Orientation ) ),
 this, SLOT( handleOrientationChanged( Qt::Orientation ) ) );
 MPX_DEBUG(
 _L("QMPXVideoPlaybackControlsController::initializeController() orientation = %d, ok =%d"),
 mOrientation, ok );
 setParent( mView );
 mView->hideItems( Hb::AllItems );
 mLoader = NULL;
 }
 mFileDetails->mRNFormat = realFormat( mFileDetails->mClipName );
+//
+// Controls dismissing timer
+//
 mControlsTimer = new QTimer( this );
 mControlsTimer->setInterval( KMPXControlsTimeOut );
 mControlsTimer->setSingleShot( false );
 connect( mControlsTimer, SIGNAL( timeout() ), this, SLOT( hideAllControls() ) );
-connect( mView, SIGNAL( tappedOnScreen() ), this, SLOT( handleTappedOnScreen() ) );
 mControlsPolicy = new QMPXVideoPlaybackControlPolicy();
 mControlsConfig = new QMPXVideoPlaybackControlConfiguration( this );
 connect( mControlsConfig, SIGNAL( controlListUpdated() ), this, SLOT( controlsListUpdated() ) );
 mControlsConfig->createControlList();
 //
 mVolumeControl->setTimeout( KMPXControlsTimeOut );
 mVolumeControl->setTickPosition( Hb::NoSliderTicks );
 mVolumeControl->setRange( KPbPlaybackVolumeLevelMin, KPbPlaybackVolumeLevelMax );
 //
+// grab tap gesture
+//
+mView->grabGesture( Qt::TapGesture );
+connect( mView, SIGNAL( tappedOnScreen() ), this, SLOT( handleTappedOnScreen() ) );
+//
+// grab pan gesture for playlist
+//
+if ( mFileDetails->mMultiItemPlaylist )
+{
+mView->grabGesture( Qt::PanGesture );
+connect( mView, SIGNAL( pannedToRight() ), this, SLOT( skipToPreviousVideoItem() ) );
+connect( mView, SIGNAL( pannedToLeft() ), this, SLOT( skipToNextVideoItem() ) );
+}
+//
 // if videoplayback is in service mode, create a videoservices instance
 //
 if ( XQServiceUtil::isService() && ! mVideoServices )
 {
 //
 // obtain VideoServices instance
 //
 mVideoServices = VideoServices::instance();
 //
 // allow 'attach' operation only for non-streaming media clips
 //
 if ( mVideoServices && mFileDetails->mPlaybackMode == EMPXVideoLocal )
 {
 //
 // determine if this is 'attach' operation
 //
 mIsAttachOperation = ( mVideoServices->currentService() == VideoServices::EUriFetcher );
 if ( mIsAttachOperation )
 {
 //
 // connect signal filePath() to videoservices slot itemSelected()
 //
 connect( this, SIGNAL( attachVideoPath( const QString& ) ),
 mVideoServices, SLOT( itemSelected( const QString& ) ) );
 }
 }
 }
 }
 //
 QMPXVideoPlaybackControlsController::~QMPXVideoPlaybackControlsController()
 {
 MPX_ENTER_EXIT(_L("QMPXVideoPlaybackControlsController::~QMPXVideoPlaybackControlsController()"));
+mView->ungrabGesture( Qt::TapGesture );
+disconnect( mView, SIGNAL( tappedOnScreen() ), this, SLOT( handleTappedOnScreen() ) );
+if ( mFileDetails->mMultiItemPlaylist )
+{
+mView->ungrabGesture( Qt::PanGesture );
+disconnect( mView, SIGNAL( pannedToRight() ), this, SLOT( skipToNextVideoItem() ) );
+disconnect( mView, SIGNAL( pannedToLeft() ), this, SLOT( skipToPreviousVideoItem() ) );
+}
 disconnect( mControlsConfig, SIGNAL( controlListUpdated() ), this, SLOT( controlsListUpdated() ) );
-disconnect( mView, SIGNAL( tappedOnScreen() ), this, SLOT( handleTappedOnScreen() ) );
 disconnect( mControlsTimer, SIGNAL( timeout() ), this, SLOT( hideAllControls() ) );
 disconnect( hbInstance->allMainWindows()[0], SIGNAL( orientationChanged( Qt::Orientation ) ),
 this, SLOT( handleOrientationChanged( Qt::Orientation ) ) );
 mView->setWidget( NULL );
 mControlsTimer = NULL;
 }
 if ( mRNLogoTimer )
 {
 disconnect( mRNLogoTimer, SIGNAL( timeout() ), this, SLOT( handleRNLogoTimeout() ) );
 delete mRNLogoTimer;
 mRNLogoTimer = NULL;
 }
 }
 if ( mThumbnailManager )
 {
 delete mThumbnailManager;
 mThumbnailManager = NULL;
 }
 if ( mVolumeControl )
 {
 delete mVolumeControl;
 mVolumeControl = NULL;
 }
 if ( mIsAttachOperation )
 {
 //
 // disable connection for 'attach' operation
 //
 disconnect( this, SIGNAL( attachVideoPath( const QString& ) ),
 mVideoServices, SLOT( itemSelected( const QString& ) ) );
 }
 if ( mVideoServices )
 {
 //
 // decrease videoservices instance count
 //
 	mVideoServices->decreaseReferenceCount();
 	mVideoServices = 0;
 QMPXVideoPlaybackViewFileDetails* details )
 {
 MPX_ENTER_EXIT(_L("QMPXVideoPlaybackControlsController::addFileDetails"));
 mFileDetails = details;
+mFileDetails->mRNFormat = realFormat( mFileDetails->mClipName );
 mControlsConfig->updateControlsWithFileDetails();
 //
 // for audio-only clips and tv-out, default view is flip view
 break;
 }
 default:
 {
 break;
 }
 }
 }
 }
 //
 //  Control exists in new list.
 //  Update the policy property based on file details and view mode to the controls
 //
 TUint properties = 0;
 mControlsPolicy->setControlProperties(
 mControls[i]->controlIndex(), properties, mFileDetails, mViewMode );
 mControls[i]->updateControlProperties( properties );
 //
 //  Control exists in new list.
 {
 //
 // Status key (signal + title + back key)
 //
 control = new QMPXVideoPlaybackStatusPaneControl( this,
 controlIndex,
 NULL,
 properties );
 mControls.append( control );
 break;
 {
 //
 // Button bar
 //
 QGraphicsWidget *widget = mLoader->findWidget( QString( "controlBarLayout" ) );
 QMPXVideoPlaybackControlBar *controlBar =
 qobject_cast<QMPXVideoPlaybackControlBar*>( widget );
 controlBar->initialize();
 control = new QMPXVideoPlaybackFullScreenControl( this,
 controlIndex,
 break;
 }
 case EMPXFileDetailsWidget:
 {
 QGraphicsWidget *widget = mLoader->findWidget( QString( "fileDetailsLayout" ) );
 QMPXVideoPlaybackFileDetailsWidget *fileDetails =
 qobject_cast<QMPXVideoPlaybackFileDetailsWidget*>( widget );
 control = new QMPXVideoPlaybackFullScreenControl( this,
 controlIndex,
 fileDetails,
 break;
 }
 case EMPXDetailsViewPlaybackWindow:
 {
 QGraphicsWidget *widget = mLoader->findWidget( QString( "detailsPlaybackWindow" ) );
 QMPXVideoPlaybackDetailsPlaybackWindow *detailsPlaybackWindow =
 qobject_cast<QMPXVideoPlaybackDetailsPlaybackWindow*>( widget );
 detailsPlaybackWindow->initialize();
 control = new QMPXVideoPlaybackFullScreenControl( this,
 controlIndex,
 {
 MPX_ENTER_EXIT(_L("QMPXVideoPlaybackControlsController::handleTappedOnScreen()"));
 //
-//  Toggle visibility only if the followings are true
+// If we are in full screen view, toggle the visibility when playing and paused
-//  - TV-Out is not connected
+// If we are in details view, issue playpause
-//  - Video is available
+// If we are in audio only view, ignore
-//  - We are in playing or paused state
+//
-//
+switch( mViewMode )
-if ( ! isTvOutConnected() &&
+{
-mFileDetails->mVideoEnabled &&
+case EFullScreenView:
-( mState == EPbStatePlaying || mState == EPbStatePaused ) )
+{
-{
+if ( mState == EPbStatePlaying || mState == EPbStatePaused )
-if ( mViewMode == EFullScreenView )
-{
-if ( isVisible() )
 {
-//
+if ( isVisible() )
-// If the volume control is visible, hide it
-//
-if ( mVolumeControl->isVisible() )
 {
-mVolumeControl->setVisible( false );
+//
+// If the volume control is visible, hide it
+//
+if ( mVolumeControl->isVisible() )
+{
+mVolumeControl->setVisible( false );
+}
+hideAllControls();
 }
+else
-hideAllControls();
+{
+showControls();
+}
 }
-else
-{
+break;
-showControls();
+}
-}
+case EDetailsView:
+{
+handleCommand( EMPXPbvCmdPlayPause );
+break;
 }
 }
 }
 // -------------------------------------------------------------------------------------------------
 {
 for ( int i = 0 ; i < mControls.count() ; i++ )
 {
 mControls[i]->setVisibility( mState );
 }
 }
 }
 // -------------------------------------------------------------------------------------------------
 //   QMPXVideoPlaybackControlsController::isVisible()
 // -------------------------------------------------------------------------------------------------
 // -------------------------------------------------------------------------------------------------
 //   QMPXVideoPlaybackControlsController::handleCommand()
 // -------------------------------------------------------------------------------------------------
 //
 void QMPXVideoPlaybackControlsController::handleCommand(
 TMPXVideoPlaybackViewCommandIds command, int value )
 {
 MPX_DEBUG(_L("QMPXVideoPlaybackControlsController::handleCommand(%d)"), command);
 switch( command )
 {
 case EMPXPbvCmdSetPosition:
 {
 TRAP_IGNORE( mViewWrapper->SetPropertyL( EPbPropertyPosition,
 value * KPbMilliMultiplier ) );
 break;
 }
 case EMPXPbvCmdSetVolume:
 {
 TRAP_IGNORE( mViewWrapper->SetPropertyL( EPbPropertyVolume, value ) );
 break;
 }
 default:
 {
 TRAP_IGNORE( mViewWrapper->HandleCommandL( command ) );
 break;
 if ( fileName->Des()[j]== '\\' )
 {
 fileName->Des()[j]='/';
 }
 }
 err = filePath.Set( fileName->Des(), NULL, NULL );
 }
 if ( fileName )
 {
 delete fileName;
 // -------------------------------------------------------------------------------------------------
 //
 bool QMPXVideoPlaybackControlsController::realFormatForLocal()
 {
 bool realFormat = false;
 QString real( "real" );
 QString rn( "rn" );
 if ( mFileDetails->mMimeType.contains( real, Qt::CaseInsensitive ) ||
 mFileDetails->mMimeType.contains( rn, Qt::CaseInsensitive ) )
 {
 realFormat = true;
 }
 {
 generateThumbNail();
 }
 //
 // Change the view.
 // If Tv-out is connected, go to AudioOnlyView.
 // If not, go back to default view.
 //
 TPlaybackViewMode viewMode = EFullScreenView;
 // -------------------------------------------------------------------------------------------------
 //   QMPXVideoPlaybackControlsController::changeViewMode
 // -------------------------------------------------------------------------------------------------
 //
 void QMPXVideoPlaybackControlsController::changeViewMode(
 TPlaybackViewMode viewMode, bool transitionEffect )
 {
 MPX_DEBUG(_L("QMPXVideoPlaybackControlsController::changeViewMode( %d, %d )"),
 viewMode, transitionEffect );
 //
 void QMPXVideoPlaybackControlsController::skipToPreviousVideoItem()
 {
 MPX_DEBUG(_L("QMPXVideoPlaybackControlsController::skipToPreviousVideoItem()"));
-handleCommand( EMPXPbvCmdPreviousListItem );
+if ( mViewMode == EFullScreenView )
+{
+handleCommand( EMPXPbvCmdPreviousListItem );
+}
 }
 // -------------------------------------------------------------------------------------------------
 //   QMPXVideoPlaybackControlsController::skipToNextVideoItem
 // -------------------------------------------------------------------------------------------------
 //
 void QMPXVideoPlaybackControlsController::skipToNextVideoItem()
 {
 MPX_DEBUG(_L("QMPXVideoPlaybackControlsController::skipToNextVideoItem()"));
-handleCommand( EMPXPbvCmdNextListItem );
+if ( mViewMode == EFullScreenView )
+{
+handleCommand( EMPXPbvCmdNextListItem );
+}
 }
 // -------------------------------------------------------------------------------------------------
 //   QMPXVideoPlaybackControlsController::updateVideoRect()
 // -------------------------------------------------------------------------------------------------
 QRectF rect;
 MPX_DEBUG(_L("QMPXVideoPlaybackControlsController::updateVideoRect() : mViewMode = %d )"),
 mViewMode );
 if ( mViewMode == EDetailsView )
 {
 QGraphicsWidget *parent = mLoader->findWidget( QString( "detailsPlaybackWindow" ) );
 QGraphicsWidget *child = mLoader->findWidget( QString( "small_transparentWindow" ) );
 {
 QGraphicsWidget *widget = mLoader->findWidget( QString( "content" ) );
 rect = widget->geometry();
 }
 mViewWrapper->UpdateVideoRect(
 rect.x(), rect.y(), rect.width(), rect.height(), transitionEffect );
 }
 }
 // -------------------------------------------------------------------------------------------------
 if ( mFileDetails->mTvOutConnected )
 {
 tvOutBitmap->setVisible( true );
 }
 else if ( mFileDetails->mRNFormat )
 {
 realAudioOnlyBitmap->setVisible( true );
 }
 else if ( mFileDetails->mPartialPlayback )
 {
 }
 else
 {
 audioOnlyBitmap->setVisible( true );
 }
 }
 }
 // -------------------------------------------------------------------------------------------------
 //   QMPXVideoPlaybackControlsController::generateThumbNail()
 // -------------------------------------------------------------------------------------------------
 //
 if ( mFileDetails->mPlaybackMode == EMPXVideoLocal )
 {
 if ( mThumbNailState == EThumbNailEmpty )
 {
 mThumbnailManager = new ThumbnailManager(); ;
 mThumbnailManager->setThumbnailSize( ThumbnailManager::ThumbnailLarge );
 mThumbnailManager->setQualityPreference( ThumbnailManager::OptimizeForPerformance );
 if ( connect( mThumbnailManager, SIGNAL( thumbnailReady( QPixmap , void * , int , int ) ),
 this, SLOT( handleThumbnailReady( QPixmap , void * , int , int ) ) ) )
 {
 mThumbnailManager->getThumbnail( mFileDetails->mClipName );
 mThumbNailState = EThumbNailRequsted;
 }
 // -------------------------------------------------------------------------------------------------
 // QMPXVideoPlaybackControlsController::handleThumbnailReady()
 // -------------------------------------------------------------------------------------------------
 //
 void QMPXVideoPlaybackControlsController::handleThumbnailReady(
 QPixmap tnData, void *internal , int id, int error )
 {
 Q_UNUSED( internal );
 Q_UNUSED( id );
 mThumbNailState = EThumbNailNotAvailable;
 }
 setDefaultBitmap();
 disconnect( mThumbnailManager, SIGNAL( thumbnailReady( QPixmap , void * , int , int ) ),
 this, SLOT( handleThumbnailReady( QPixmap , void * , int , int ) ) );
 }
 // -------------------------------------------------------------------------------------------------
 // QMPXVideoPlaybackControlsController::attachVideo()
 //
 void QMPXVideoPlaybackControlsController::attachVideo()
 {
 MPX_ENTER_EXIT(_L("QMPXVideoPlaybackControlsController::attachVideo()"),
 _L("file = %s"), mFileDetails->mClipName.data() );
 //
 // close playback view
 //
 mView->closePlaybackView();
 //
 // emit signal to launch videoservices itemSelected() slot
 //
 emit( attachVideoPath( mFileDetails->mClipName ) );
 }
 // -------------------------------------------------------------------------------------------------
 // QMPXVideoPlaybackControlsController::sendVideo()
 // -------------------------------------------------------------------------------------------------
 //
 void QMPXVideoPlaybackControlsController::sendVideo()
 {
 MPX_ENTER_EXIT(_L("QMPXVideoPlaybackControlsController::sendVideo()"),
 _L("file = %s"), mFileDetails->mClipName.data() );
 //
 // pause playback
 //
 handleCommand( EMPXPbvCmdPause );
 //
 // send video to shareUI
 //
 ShareUi dlg;
 QStringList fileList;
 fileList.append( mFileDetails->mClipName );
 dlg.send( fileList, true );
 }
 // -------------------------------------------------------------------------------------------------
 // QMPXVideoPlaybackControlsController::handleRNLogoVisibleChanged()
 // -------------------------------------------------------------------------------------------------
 }
 mRNLogoTimer = new QTimer( this );
 mRNLogoTimer->setInterval( KMPXRNLogoTimeOut );
 mRNLogoTimer->setSingleShot( true );
 connect( mRNLogoTimer, SIGNAL( timeout() ), this, SLOT( handleRNLogoTimeout() ) );
 mRNLogoTimer->start();
 }
 }

changeset 46	adbe7d5ba2f5
parent 28	c48470be1ba7