FCL/sf/app/photos: comparison ui/viewmanagement/statehandler/src/glxstatemanager.cpp

equal deleted inserted replaced

-:f291796e213d
+:fb37077c270f
 #include "glxactionhandler.h"
 #include "glxcommandhandlers.hrh"
 #include "glxplugincommandid.hrh"
 #include "glxlog.h"
 #include "glxtracer.h"
+#include <glximageviewermanager.h>
 GlxStateManager::GlxStateManager()
 : mAllMediaModel( NULL ),
 mAlbumGridMediaModel( NULL ),
 mAlbumMediaModel( NULL ),
 qDebug("GlxStateManager::GlxStateManager");
 PERFORMANCE_ADV ( d1, "view manager creation time") {
 mViewManager = new GlxViewManager();
 }
 mTNObserver = new GlxTNObserver();
-mSaveActivity.clear();
 connect ( this, SIGNAL( setupItemsSignal() ), this, SLOT( setupItems() ), Qt::QueuedConnection );
 connect ( mViewManager, SIGNAL(actionTriggered( qint32 )), this, SLOT(actionTriggered( qint32 )), Qt::QueuedConnection );
 connect ( mTNObserver, SIGNAL( leftTNCount( int ) ), this, SLOT( updateTNProgress( int ) ) );
 connect ( qobject_cast<HbApplication*>(qApp), SIGNAL (aboutToQuit()), this, SLOT(saveData()));
 mTNObserver->stopTNMDaemon();
 }
 return QObject::eventFilter(obj, event);
 }
+void GlxStateManager::launchFetcher()
+{
+qDebug("GlxStateManager::launchFetcher");
+mCurrentState = createState(GLX_GRIDVIEW_ID);
+mCurrentState->setState(FETCHER_ITEM_S);
+createModel(GLX_GRIDVIEW_ID);
+mViewManager->launchApplication( GLX_GRIDVIEW_ID, mCurrentModel);
+}
 void GlxStateManager::launchApplication()
 {
 qDebug("GlxStateManager::launchApplication");
 bool activitySuccess = false;
 //To:Do use it in future once performance code is removed nextState(GLX_GRIDVIEW_ID, ALL_ITEM_S)
 HbApplication* app = qobject_cast<HbApplication*>(qApp);
 if(app->activateReason() == Hb::ActivationReasonActivity) {
 activitySuccess = launchActivity();
 }
-if( !activitySuccess ) {
-mCurrentState = createState( GLX_GRIDVIEW_ID );
+if( !activitySuccess ) {
-mCurrentState->setState( ALL_ITEM_S );
+mCurrentState = createState( GLX_GRIDVIEW_ID );
+mCurrentState->setState( ALL_ITEM_S );
-int leftCount = mTNObserver->getTNLeftCount() ;
-if (  leftCount > 0  ) {
+int leftCount = mTNObserver->getTNLeftCount() ;
-mViewManager->launchApplication( GLX_GRIDVIEW_ID, mCurrentModel);
+if (  leftCount > 0  ) {
-launchProgressDialog();
+mViewManager->launchApplication( GLX_GRIDVIEW_ID, mCurrentModel );
-}
+launchProgressDialog();
-else {
+}
-createModel( GLX_GRIDVIEW_ID );
+else {
-mViewManager->launchApplication( GLX_GRIDVIEW_ID, mCurrentModel);
+createModel( GLX_GRIDVIEW_ID );
-}
+mViewManager->launchApplication( GLX_GRIDVIEW_ID, mCurrentModel );
+}
 mTNObserver->startTNObserving() ;
 }
-//Remove the previous activity
 HbActivityManager* activityManager = app->activityManager();
 bool ok = activityManager->removeActivity("PhotosMainView");
 if ( !ok )
 {
 qDebug("launchapplication::Remove activity failed" );
 }
 }
 bool GlxStateManager::launchActivity()
 {
 HbApplication* app = qobject_cast<HbApplication*>(qApp);
 bool ok = app->activityManager()->waitActivity();
 if ( !ok )
 {
 qDebug("subscribing to activity manager failed" );
-//return false;  TBD: waitActivity is always returning false. Could be some issue with AM.
 }
 QVariant data = app->activityManager()->activityData( "PhotosMainView" );
 QByteArray serializedModel = data.toByteArray();
 QDataStream stream(&serializedModel, QIODevice::ReadOnly);
 //Fetch the data from the activity Manager
-QMap<QString, qint32> fetchActivity;
+stream >> mSaveActivity;
-stream >> fetchActivity;
+qint32 stateId = mSaveActivity.value("ID");
-qint32 stateId = fetchActivity.value("ID");
 mCurrentState = createState(stateId);
-mCurrentState->setState( fetchActivity.value("InternalState") );
+mCurrentState->setState( mSaveActivity.value("InternalState") );
 createModel( stateId);
 	/*Model might not be populated yet to set the visibleWindowIndex right away.
 	*So, let us store the visible index as a temporary Variable, so that  visible Window Index
 	*is set once the model is populated.
 */
-mCurrentModel->setData(QModelIndex(), fetchActivity.value("VisibleIndex") , GlxTempVisualWindowIndex );
+mCurrentModel->setData(QModelIndex(), mSaveActivity.value("VisibleIndex") , GlxTempVisualWindowIndex );
 mViewManager->launchApplication(stateId, mCurrentModel);
 return true;
 }
 void GlxStateManager::launchFromExternal()
 {
-qDebug("GlxStateManager::launchApplication");
+qDebug("GlxStateManager::launchFromExternal");
 mCurrentState = createState(GLX_FULLSCREENVIEW_ID);
 mCurrentState->setState(IMAGEVIEWER_S);
 createModel(GLX_FULLSCREENVIEW_ID);
 mCurrentModel->setData( mCurrentModel->index(0,0), 0, GlxFocusIndexRole );
 {
 qDebug("GlxStateManager::setupItems()");
 mActionHandler = new GlxActionHandler();
 connect ( mViewManager, SIGNAL(externalCommand(int )), this, SIGNAL(externalCommand(int )) );
 mViewManager->setupItems();
-mViewManager->updateToolBarIcon(GLX_ALL_ACTION_ID);
+switch( mSaveActivity.value( "ID" ) ){
+case GLX_LISTVIEW_ID:
+mViewManager->updateToolBarIcon(GLX_ALBUM_ACTION_ID);
+break;
+case GLX_GRIDVIEW_ID:
+default:
+mViewManager->updateToolBarIcon(GLX_ALL_ACTION_ID);
+}
 }
 void GlxStateManager::updateTNProgress( int count)
 {
 TRACER("GlxStateManager::updateTNProgress() ");
-// mCurrentModel ------------this is case when progress bar is not showing
+// this is case when progress bar is not showing
-// count > 5 ----------------in the case of rename of an image or capture the single item
+// in the case of rename of an image or capture the single item
-//                           it is also launching the progress bar, to avoid this scenario add the check of count more than 5
+// it is also launching the progress bar, to avoid this scenario add the check of count more than 5
-// count == KErrNotReady ----A case when memory card is inserted but it is not harvest so it is given an error
-//                           In that case also user should be block to browse the images
 if ( mCurrentModel && ( count > 5  ) ) {
 goBack( GLX_GRIDVIEW_ID, ALL_ITEM_S ) ;
 cleanAllModel();
 launchProgressDialog();
 }
 if ( isProgressbarRunning ){
 if ( count == 0 ) {
-createModel( mCurrentState->id() );
-mViewManager->setModel( mCurrentModel );
 vanishProgressDialog();
 }
 else {
 mViewManager->updateProgressDialog( count );
 }
 }
 }
+void GlxStateManager::thumbnailPopulated()
+{
+mViewManager->setModel( mCurrentModel );
+isProgressbarRunning = false;
+mViewManager->updateProgressDialog( 0 );
+disconnect ( mCurrentModel, SIGNAL( thumbnailPopulated() ), this, SLOT( thumbnailPopulated() ) );
+}
 void GlxStateManager::saveData()
 {
 if( (mCurrentState->id() == GLX_GRIDVIEW_ID && mCurrentState->state() == ALL_ITEM_S) || mCurrentState->id() == GLX_LISTVIEW_ID ) {
 mSaveActivity.insert("ID",mCurrentState->id());
 mSaveActivity.insert("InternalState",mCurrentState->state());
+if(mCurrentModel) {
-//Store the visual Index
+QVariant variant = mCurrentModel->data( mCurrentModel->index(0,0), GlxVisualWindowIndex );
-if(mCurrentModel)
+if ( variant.isValid() &&  variant.canConvert<int> () ) {
-{
+mSaveActivity.insert("VisibleIndex",variant.value<int>());
-	QVariant variant = mCurrentModel->data( mCurrentModel->index(0,0), GlxVisualWindowIndex );
+}
-	if ( variant.isValid() &&  variant.canConvert<int> () ) {
-mSaveActivity.insert("VisibleIndex",variant.value<int>());
-	}
 		}
-		else
+		else {
-			   mSaveActivity.insert("VisibleIndex",0);
+			mSaveActivity.insert("VisibleIndex",0);
+		}
-HbActivityManager* activityManager = qobject_cast<HbApplication*>(qApp)->activityManager();
+HbActivityManager* activityManager = qobject_cast<HbApplication*>(qApp)->activityManager();
-//Take a screenshot
+QVariantHash metadata;
-QVariantHash metadata;
+HbMainWindow *window = hbInstance->allMainWindows().first();
-HbMainWindow *window = hbInstance->allMainWindows().first();
+metadata.insert("screenshot", QPixmap::grabWidget(window, window->rect()));
-metadata.insert("screenshot", QPixmap::grabWidget(window, window->rect()));
+QByteArray serializedModel;
-QByteArray serializedModel;
+QDataStream stream(&serializedModel, QIODevice::WriteOnly | QIODevice::Append);
-QDataStream stream(&serializedModel, QIODevice::WriteOnly | QIODevice::Append);
+stream << mSaveActivity;
-stream << mSaveActivity;
-//Add the activity
+bool ok = activityManager->addActivity("PhotosMainView", serializedModel, metadata);
-bool ok = activityManager->addActivity("PhotosMainView", serializedModel, metadata);
+if ( !ok )
-if ( !ok )
+{
-{
+qDebug("SaveData::Add activity failed" );
-qDebug("SaveData::Add activity failed" );
+}
 }
 }
-}
 void GlxStateManager::nextState(qint32 state, int internalState)
 {
 qDebug("GlxStateManager::nextState next state = %u", state);
 GlxEffect effect = NO_EFFECT ;
 GlxViewEffect viewEffect = NO_VIEW ;
 GlxState *state = mCurrentState; // To delete the current state later
 if ( mCurrentState->previousState() == NULL ) { //In the case only one state in stack then exit from the application
+saveImage(); // save image if it is in private folder
 exitApplication() ;
 return ;
 }
 else {
 //effect parameter should be set here other wise there is no way to know from where it come from
 mViewManager->launchView( mCurrentState->id(), mCurrentModel, effect, viewEffect);
 }
 }
 delete state;
 }
+void GlxStateManager::saveImage()
+{
+CGlxImageViewerManager *imageViewerInstance = CGlxImageViewerManager::InstanceL();
+if(imageViewerInstance->IsPrivate())
+{
+HBufC* imagePath = imageViewerInstance->ImageUri();
+		QString srcPath = QString::fromUtf16(imagePath->Des().Ptr(),imagePath->Length());
+		QString imageName = srcPath.section('\\', -1);
+		QString imagesFolderPath("c:/data/images/");
+		QString destPath;
+		destPath.append(imagesFolderPath);
+		destPath.append(imageName);
+		int cnt = 1;
+		qDebug() << "GlxStateManager::saveImage path before while = "<< destPath;
+		while(!QFile::copy(srcPath,destPath))
+			{
+			QString filename = imageName.section('.', 0,0);
+			QString ext = imageName.section('.', -1);
+			destPath.clear();
+			destPath = imagesFolderPath + filename + QString::number(cnt) + "." + ext;
+			qDebug() << "GlxStateManager::saveImage path = "<< destPath;
+			cnt++;
+			}
+}
+imageViewerInstance->Close();
+}
 void GlxStateManager::goBack(qint32 stateId, int internalState)
 {
 qDebug("GlxStateManager::goBack()");
 //if current state and it internal state is same then no need to do any thing
 }
 void GlxStateManager::launchProgressDialog()
 {
 TRACER("GlxStateManager::launchProgressDialog() ");
-//HbMainWindow *window = hbInstance->allMainWindows().first();
-//window->setAutomaticOrientationEffectEnabled( true );
 QCoreApplication::instance()->installEventFilter( this );
-mViewManager->launchProgressDialog( mTNObserver->getTNLeftCount() );
+if ( isProgressbarRunning ) {
+mViewManager->updateProgressDialog( mTNObserver->getTNLeftCount() );
+}
+else {
+mViewManager->launchProgressDialog( mTNObserver->getTNLeftCount() );
+}
 isProgressbarRunning = true ;
 }
 void GlxStateManager::vanishProgressDialog()
 {
 TRACER("GlxStateManager::vanishProgressDialog() ");
-//HbMainWindow *window = hbInstance->allMainWindows().first();
-//window->setAutomaticOrientationEffectEnabled( false );
 QCoreApplication::instance()->removeEventFilter( this );
-isProgressbarRunning = false;
+createModel( mCurrentState->id() );
-mViewManager->updateProgressDialog( 0 );
+connect ( mCurrentModel, SIGNAL( thumbnailPopulated() ), this, SLOT( thumbnailPopulated() ) );
 }
 GlxState * GlxStateManager::createState(qint32 stateId)
 {
 qDebug("GlxStateManager::createState state id = %d", stateId);
 case GLX_LISTVIEW_ID :
 return new GlxListState( mCurrentState );
 case GLX_FULLSCREENVIEW_ID :
-return new GlxFullScreenState( mCurrentState );
+return new GlxFullScreenState( this, mCurrentState );
 case GLX_DETAILSVIEW_ID:
 return new GlxDetailState( mCurrentState );
 case GLX_SLIDESHOWVIEW_ID :
 mode = GlxContextPtGrid ;
 }
 switch( internalState) {
 case ALL_ITEM_S :
+	case FETCHER_ITEM_S:
 if ( mAllMediaModel == NULL ) {
 modelParm.setCollection( KGlxCollectionPluginAllImplementationUid );
 modelParm.setDepth(0);
 modelParm.setContextMode( mode ) ;
 mAllMediaModel = new GlxMediaModel( modelParm );
 mCurrentModel = mAllMediaModel;
 mViewManager->updateToolBarIcon(GLX_ALL_ACTION_ID);
 break;
 case ALBUM_ITEM_S :
+case FETCHER_ALBUM_ITEM_S :
 if ( dir != BACKWARD_DIR ) {
 modelParm.setCollection( KGlxAlbumsMediaId );
 modelParm.setDepth(0);
 modelParm.setContextMode( mode ) ;
 mAlbumGridMediaModel = new GlxMediaModel( modelParm );
 switch(id) {
 case EGlxCmdAllGridOpen :
 changeState( GLX_GRIDVIEW_ID, ALL_ITEM_S );
 id = EGlxCmdHandled;
 break;
+case EGlxCmdFetcherAllGridOpen :
+changeState( GLX_GRIDVIEW_ID, FETCHER_ITEM_S );
+id = EGlxCmdHandled;
+break;
 case EGlxCmdAlbumListOpen:
 changeState( GLX_LISTVIEW_ID, -1 );
 id = EGlxCmdHandled;
 break;
+case EGlxCmdFetcherAlbumListOpen:
+changeState( GLX_LISTVIEW_ID, FETCHER_ALBUM_S );
+id = EGlxCmdHandled;
+break;
 case EGlxCmdAlbumGridOpen:
 nextState( GLX_GRIDVIEW_ID, ALBUM_ITEM_S );
 id = EGlxCmdHandled;
 break;
+case EGlxCmdFetcherAlbumGridOpen:
+nextState( GLX_GRIDVIEW_ID, FETCHER_ALBUM_ITEM_S );
+id = EGlxCmdHandled;
+break;
 case EGlxCmdFirstSlideshow :
 //play the slide show with first item
 mCurrentModel->setData( mCurrentModel->index(0, 0), 0, GlxFocusIndexRole );
 nextState( GLX_SLIDESHOWVIEW_ID, SLIDESHOW_GRID_ITEM_S );
 id = EGlxCmdHandled;
 id = EGlxCmdHandled;
 break;
 }
 case EGlxCmdBack :
+case EGlxCmdSlideShowBack :
 	previousState();
 	id = EGlxCmdHandled;
 	break;
 case EGlxCmdCameraOpen:
 }
 mActionHandler->handleAction(id,mCollectionId);
 		}
 break;
-case EGlxCmdMarkAll:
+case EGlxCmdMarkAll :
-case EGlxCmdUnMarkAll:
+case EGlxCmdUnMarkAll :
-mViewManager->handleUserAction(mCurrentState->id(), id);
+case EGlxCmd3DEffectOn :
+case EGlxCmd3DEffectOff :
+case EGlxCmdPlayBackAnim :
+mViewManager->handleUserAction( mCurrentState->id(), id );
 id = EGlxCmdHandled;
 break;
 case EGlxCmdSetupItem :
 emit setupItemsSignal();
 break;
+case EGlxCmdFetcherSelect:
+{
+QModelIndex selectedIndex = mCurrentModel->index(mCurrentModel->data(mCurrentModel->index(0,0),GlxFocusIndexRole).value<int>(),0);
+emit gridItemSelected(selectedIndex,*mCurrentModel);
+id = EGlxCmdHandled;
+}
+break;
 default :
 mActionHandler->handleAction(id,mCollectionId);
 	break;
 }
 }
 GlxStateManager::~GlxStateManager()
 {
 qDebug("GlxStateManager::~GlxStateManager");
 cleanAllModel();
+mSaveActivity.clear();
 delete mActionHandler;
 qDebug("GlxStateManager::~GlxStateManager delete Model");
 disconnect ( mViewManager, SIGNAL(actionTriggered(qint32 )), this, SLOT(actionTriggered(qint32 )) );
 disconnect ( mViewManager, SIGNAL(externalCommand(int )), this, SIGNAL(externalCommand(int )) );

changeset 55	fb37077c270f
parent 49	f291796e213d
child 70	a91aa46552be