FCL/sf/app/videoplayer: comparison videoplayerapp/videoplayerengine/src/videoplayerengine.cpp

equal deleted inserted replaced

-:adbe7d5ba2f5
+:45e72b57a2fd
 *
 * Description:  Implementation of VideoPlayerEngine
 *
 */
-// Version : %version: 33 %
+// Version : %version: da1mmcf#37 %
 #include <QApplication>
 #include <hbinstance.h>
 // -------------------------------------------------------------------------------------------------
 //
 QVideoPlayerEngine::~QVideoPlayerEngine()
 {
 MPX_ENTER_EXIT(_L("QVideoPlayerEngine::~QVideoPlayerEngine()"));
 if ( mVideoServices )
 {
 	mVideoServices->decreaseReferenceCount();
 	mVideoServices = 0;
 }
 if ( mCollectionViewPlugin )
 {
 mCollectionViewPlugin->destroyView();
 		delete mCollectionViewPlugin;
 		mCollectionViewPlugin = 0;
 }
 if ( mPlaybackViewPlugin )
 {
 mPlaybackViewPlugin->destroyView();
 		delete mPlaybackViewPlugin;
 		mPlaybackViewPlugin = 0;
 }
 if ( mFileDetailsViewPlugin )
 {
 mFileDetailsViewPlugin->destroyView();
 		delete mFileDetailsViewPlugin;
 		mFileDetailsViewPlugin = 0;
 }
 delete mPlaybackWrapper;
 // disconnect all signals
 disconnect();
 }
 // -------------------------------------------------------------------------------------------------
 // initialize()
 // -------------------------------------------------------------------------------------------------
 //
 void QVideoPlayerEngine::initialize()
 {
 MPX_ENTER_EXIT(_L("QVideoPlayerEngine::initialize()"));
 //
 // Clean up QVideoPlayerEngine when qApp try to quit
 //
 connect( qApp, SIGNAL( aboutToQuit() ), this, SLOT( handleQuit() ) );
 SLOT( handleCommand( int ) ) );
 }
 QList<XQPluginInfo> impls;
 XQPluginLoader::listImplementations("org.nokia.mmdt.MpxViewPlugin/1.0", impls);
 if ( mIsService )
 {
 if(!mVideoServices)
 {
 mVideoServices = VideoServices::instance(this);
 connect( mVideoServices, SIGNAL(activated(int)), this, SLOT(handleCommand(int)));
 }
 if ( isPlayServiceInvoked() )
 {
 createPlaybackView();
 }
 else
 {
 loadPluginAndCreateView( MpxHbVideoCommon::CollectionView );
 // Browse service will activate view once the category to be opened is informed from highway
 // since the category is not known at this point, we do not activate view for it here
 if(!(XQServiceUtil::interfaceName().contains("IVideoBrowse")))
 {
 activateView( MpxHbVideoCommon::CollectionView );
 }
 }
 }
 else
 {
 // check latest plugin type from activity manager data and create + activate it
 // CollectionView (default) and playbackview are the ones that are accepted
 MpxHbVideoCommon::MpxHbVideoViewType viewType = MpxHbVideoCommon::CollectionView;
-int typeGotten = VideoActivityState::instance().getActivityData(VideoActivityData::KEY_VIEWPLUGIN_TYPE).toInt();
+int typeGotten = VideoActivityState::instance().getActivityData(KEY_VIEWPLUGIN_TYPE).toInt();
-if(typeGotten == MpxHbVideoCommon::CollectionView || typeGotten == MpxHbVideoCommon::PlaybackView)
-{
+if ( typeGotten == MpxHbVideoCommon::PlaybackView )
+{
+createPlaybackView();
 viewType = MpxHbVideoCommon::MpxHbVideoViewType(typeGotten);
-}
+QVariant data = VideoActivityState::instance().getActivityData(KEY_LAST_PLAYED_CLIP);
-loadPluginAndCreateView( viewType );
+playMedia( data.toString() );
-activateView( viewType );
+}
-}
+else
+{
+loadPluginAndCreateView( viewType );
+activateView( viewType );
+}
+}
 }
 // -------------------------------------------------------------------------------------------------
 // handleCommand()
 // -------------------------------------------------------------------------------------------------
 //
 void QVideoPlayerEngine::handleCommand( int commandCode )
 {
 MPX_ENTER_EXIT(_L("QVideoPlayerEngine::handleCommand()"),
 _L("commandCode = %d"), commandCode );
 switch ( commandCode )
 {
 case MpxHbVideoCommon::ActivateCollectionView:
 {
 if ( mCurrentViewPlugin != mCollectionViewPlugin )
 {
 activateView( MpxHbVideoCommon::CollectionView );
 }
 break;
 }
 case MpxHbVideoCommon::ActivatePlaybackView:
 {
 if ( mCurrentViewPlugin != mPlaybackViewPlugin )
 {
 activateView( MpxHbVideoCommon::PlaybackView );
 }
 break;
 }
 case MpxHbVideoCommon::ActivateVideoDetailsView:
 {
 if ( mCurrentViewPlugin != mFileDetailsViewPlugin )
 {
 activateView( MpxHbVideoCommon::VideoDetailsView );
 }
 break;
 }
 case MpxHbVideoCommon::DoDelayedLoad:
 {
 {
 doDelayedLoad();
 }
 break;
 }
 default:
 {
 break;
 }
 }
 }
 // -------------------------------------------------------------------------------------------------
 // doDelayedLoad()
 // -------------------------------------------------------------------------------------------------
 //
 void QVideoPlayerEngine::doDelayedLoad()
 {
 MPX_ENTER_EXIT(_L("QVideoPlayerEngine::doDelayedLoad()"));
 createMissingViews();
 mDelayedLoadDone = true;
 }
 // -------------------------------------------------------------------------------------------------
 // createPlaybackView()
 // -------------------------------------------------------------------------------------------------
 //
 void QVideoPlayerEngine::createPlaybackView()
 {
+MPX_ENTER_EXIT(_L("QVideoPlayerEngine::createPlaybackView()"));
 mPlaybackWrapper->lateInit();
 if ( ! mPlaybackViewPlugin )
 {
 loadPluginAndCreateView( MpxHbVideoCommon::PlaybackView );
 }
 }
 // -------------------------------------------------------------------------------------------------
 //
 void QVideoPlayerEngine::createMissingViews()
 {
 MPX_ENTER_EXIT(_L("QVideoPlayerEngine::createMissingViews()"));
 //
 // delayed initialization of some uiengine member variables
 // to help application startup time & improve playback start time
 //
 createPlaybackView();
 //
 void QVideoPlayerEngine::activateView( MpxHbVideoCommon::MpxHbVideoViewType viewType )
 {
 MPX_ENTER_EXIT(_L("QVideoPlayerEngine::activateView() "),
 _L("viewType = %d"), viewType );
 disconnectView();
 if ( mCurrentViewPlugin )
 {
 mCurrentViewPlugin->deactivateView();
 mCurrentViewPlugin = NULL;
 }
 case MpxHbVideoCommon::CollectionView:
 {
 if ( shouldExit() )
 {
 qApp->quit();
 XQServiceUtil::toBackground( false );
 }
 else if ( shouldActivateCollectionView()  )
 {
 if ( ! mCollectionViewPlugin )
 {
 loadPluginAndCreateView( MpxHbVideoCommon::CollectionView );
 }
 mCurrentViewPlugin = mCollectionViewPlugin;
 setCurrentView();
 }
 break;
 }
 case MpxHbVideoCommon::PlaybackView:
 {
 if ( ! mPlaybackViewPlugin )
 {
 loadPluginAndCreateView( MpxHbVideoCommon::PlaybackView );
 }
 mCurrentViewPlugin = mPlaybackViewPlugin;
 setCurrentView();
 break;
 }
 case MpxHbVideoCommon::VideoDetailsView:
 {
 if ( ! mFileDetailsViewPlugin )
 {
 loadPluginAndCreateView( MpxHbVideoCommon::VideoDetailsView );
 }
 mCurrentViewPlugin = mFileDetailsViewPlugin;
 setCurrentView();
 break;
 }
 }
 }
 // -------------------------------------------------------------------------------------------------
 // loadPluginAndCreateView()
 // -------------------------------------------------------------------------------------------------
 //
 void QVideoPlayerEngine::loadPluginAndCreateView( MpxHbVideoCommon::MpxHbVideoViewType viewType )
 {
 MPX_ENTER_EXIT(_L("QVideoPlayerEngine::loadPluginAndCreateView() "),
 _L("viewType = %d"), viewType );
 int viewTypeUid( 0 );
 if ( viewType == MpxHbVideoCommon::CollectionView )
 {
 viewTypeUid = MpxHbVideoCommon::KMpxVideoPluginDllCollectionUid;
 }
 else if ( viewType == MpxHbVideoCommon::PlaybackView )
 {
 viewTypeUid = MpxHbVideoCommon::KMpxVideoPluginDllPlaybackUid;
 }
 else if ( viewType == MpxHbVideoCommon::VideoDetailsView )
 {
 viewTypeUid = MpxHbVideoCommon::KMpxVideoPluginDllFileDetailsUid;
 }
 if ( viewTypeUid )
 {
 //
 // load corresponding plug-in
 //
 XQPluginLoader pluginLoader( viewTypeUid );
 QObject* instance = pluginLoader.instance();
 if ( instance )
 {
 MpxViewPlugin *currentViewPlugin = NULL;
 if ( viewType == MpxHbVideoCommon::CollectionView )
 {
 mCollectionViewPlugin = qobject_cast<MpxViewPlugin*>( instance )->viewPlugin();
 currentViewPlugin = mCollectionViewPlugin;
 }
 else if ( viewType == MpxHbVideoCommon::PlaybackView )
 mFileDetailsViewPlugin = qobject_cast<MpxViewPlugin*>( instance )->viewPlugin();
 currentViewPlugin = mFileDetailsViewPlugin;
 }
 else
 {
 MPX_DEBUG(_L("QVideoPlayerEngine::loadPluginAndCreateView() : plugin not FOUND ! "));
 }
 //
 // create corresponding view
 //
 if ( currentViewPlugin )
 {
 QGraphicsWidget *view = currentViewPlugin->getView();
 if ( ! view )
 {
 MPX_DEBUG(_L("QVideoPlayerEngine::loadPluginAndCreateView() : create view "));
 currentViewPlugin->createView();
 hbInstance->allMainWindows().value(0)->addView( currentViewPlugin->getView() );
 }
 else
 {
 MPX_DEBUG(_L("QVideoPlayerEngine::loadPluginAndCreateView() : view has already been created! "));
 }
 }
 else
 {
 MPX_DEBUG(_L("QVideoPlayerEngine::loadPluginAndCreateView() : currentViewPlugin is NULL ! "));
 }
 }
 }
 }
 // -------------------------------------------------------------------------------------------------
 // -------------------------------------------------------------------------------------------------
 //
 void QVideoPlayerEngine::connectView()
 {
 MPX_ENTER_EXIT(_L("QVideoPlayerEngine::connectView()"));
 connect( mCurrentViewPlugin,
 SIGNAL( command( int ) ),
 this,
 SLOT( handleCommand( int ) ) );
 }
 // -------------------------------------------------------------------------------------------------
 //
 void QVideoPlayerEngine::disconnectView()
 {
 MPX_ENTER_EXIT(_L("QVideoPlayerEngine::disconnectView()"));
 if ( mCurrentViewPlugin )
 {
 disconnect( mCurrentViewPlugin,
 SIGNAL( command( int ) ),
 this,
 SLOT( handleCommand( int ) ) );
 }
 }
 // -------------------------------------------------------------------------------------------------
 // handleQuit()
 // -------------------------------------------------------------------------------------------------
 //
 void QVideoPlayerEngine::handleQuit()
 {
 MPX_ENTER_EXIT(_L("QVideoPlayerEngine::handleQuit()"));
 if(!mIsService)
 {
 VideoActivityState &localActivity(VideoActivityState::instance());
 QVariant data = QVariant();
 HbActivityManager *actManager = qobject_cast<HbApplication*>(qApp)->activityManager();
+//
+// deactivate is the final point for current plugin to save it's activity data into
+// VideoActivityState before they are saved to to activity manager
+//
+mCurrentViewPlugin->deactivateView();
 //
 // get and save recent view type: either playback or collection view plugins are currently used.
 // activity will not be saved from the details plugin
 //
 int viewType = MpxHbVideoCommon::CollectionView;
 if(mCurrentViewPlugin == mPlaybackViewPlugin)
 {
-viewType = MpxHbVideoCommon::PlaybackView;
+// for playback view, the state preservation and restoration should only be done
-}
+// for loacl clips (non-streaming) - so set KEY_VIEWPLUGIN_TYPE to PlaybackView only
+// for local clips. Otherwise the default value CollectionView should be set.
+//
+QVariant playdata = VideoActivityState::instance().getActivityData(KEY_LAST_LOCAL_PLAYBACK);
+if  ( playdata.toBool() )
+{
+viewType = MpxHbVideoCommon::PlaybackView;
+}
+}
 data = viewType;
-localActivity.setActivityData(data, VideoActivityData::KEY_VIEWPLUGIN_TYPE);
+localActivity.setActivityData(data, KEY_VIEWPLUGIN_TYPE);
-//
-// deactivate is the final point for current plugin to save it's activity data into
-// VideoActivityState before they are saved to to activity manager
-//
-mCurrentViewPlugin->deactivateView();
 // save data to activity manager
 actManager->addActivity(ACTIVITY_VIDEOPLAYER_MAINVIEW,
 localActivity.getActivityData(),
 QVariantHash());
 }
 delete this;
 }
 // -------------------------------------------------------------------------------------------------
 // -------------------------------------------------------------------------------------------------
 //
 void QVideoPlayerEngine::playMedia( QString filePath )
 {
 MPX_ENTER_EXIT(_L("QVideoPlayerEngine::playMedia()"),
 _L("filePath = %s"), filePath.data() );
 mPlaybackWrapper->playMedia( filePath );
 }
 // -------------------------------------------------------------------------------------------------
 // playMedia()
 // -------------------------------------------------------------------------------------------------
 //
 void QVideoPlayerEngine::playMedia( RFile file )
 {
 MPX_ENTER_EXIT(_L("QVideoPlayerEngine::playMedia( RFile )"));
 mPlaybackWrapper->playMedia( file );
 }
 // -------------------------------------------------------------------------------------------------
 // setEmbedded()
 // -------------------------------------------------------------------------------------------------
 //
 void QVideoPlayerEngine::setEmbedded()
 {
 MPX_ENTER_EXIT(_L("QVideoPlayerEngine::setEmbedded()"));
 mEmbedded = true;
 }
 // -------------------------------------------------------------------------------------------------
 // setCurrentView()
 // -------------------------------------------------------------------------------------------------
 //
 void QVideoPlayerEngine::setCurrentView()
 {
 MPX_ENTER_EXIT(_L("QVideoPlayerEngine::setCurrentView()"));
 if ( mCurrentViewPlugin )
 {
 //
 // set current view
 //
 hbInstance->allMainWindows().value(0)->setCurrentView(
 		                            qobject_cast<HbView*>( mCurrentViewPlugin->getView() ), false );
 //
 // connect view
 //
 connectView();
 //
 // activate view
 //
 mCurrentViewPlugin->activateView();
 }
 }
 // isPlayServiceInvoked()
 // -------------------------------------------------------------------------------------------------
 //
 bool QVideoPlayerEngine::isPlayServiceInvoked()
 {
 MPX_ENTER_EXIT(_L("QVideoPlayerEngine::isPlayServiceInvoked()"));
 bool result = false;
 if ( mIsService )
 {
 QString intface = XQServiceUtil::interfaceName();
 if ( intface.contains("IVideoView") ||
 intface.contains("IFileView") )
 {
 result = true;
 mIsPlayService = true;
 }
 }
 return result;
 }
 // -------------------------------------------------------------------------------------------------
 // shouldExit()
 // -------------------------------------------------------------------------------------------------
 //
 bool QVideoPlayerEngine::shouldExit()
 {
 bool result = false;
 if ( mIsPlayService )  // play or view service
 {
 result = true;
 }
 MPX_DEBUG(_L("QVideoPlayerEngine::shouldExit() return %d"), result);
 return result;
 }
 // -------------------------------------------------------------------------------------------------
 // shouldActivateCollectionView()
 // -------------------------------------------------------------------------------------------------
 //
 bool QVideoPlayerEngine::shouldActivateCollectionView()
 {
 bool result = true;
 // the only case where collection view should NOT be activated is ...
 // if we are in service and that service is fetch and if fetch is selected
 // in all other cases collection view should be activated
 if ( mIsService &&
 mVideoServices->currentService() == VideoServices::EUriFetcher &&
 mVideoServices->mFetchSelected  )
 {
 result = false;
 }
 MPX_DEBUG(_L("QVideoPlayerEngine::shouldActivateCollectionView() return %d"), result);
 return result;
 }
 // End of file

changeset 47	45e72b57a2fd
parent 46	adbe7d5ba2f5
child 52	e3cecb93e76a