MCL/sf/app/photos: comparison photosgallery/viewframework/views/fullscreenview/src/glxfullscreenviewimp.cpp

equal deleted inserted replaced

-:ce1c7ad1f18b
+:bcb43dc84c44
 #include <eikbtgpc.h>                           // CEikButtonGroupContainer
 #include <aknViewAppUi.h>
 #include <data_caging_path_literals.hrh>        // for KDC_APP_RESOURCE_DIR
 #include <glxcollectionpluginimageviewer.hrh>
 #include <StringLoader.h>                       // String Loader
+//For animation Effects
+#include <akntranseffect.h>
+#include <akntransitionutils.h>
+#include <alf/alflayout.h>
 // Alf Headers
 #include <alf/ialfwidgetfactory.h>              // widget factory
 #include <alf/alfwidgetcontrol.h>               // To get CAlfControl from CAlfWidgetControl
 #include <alf/ialfviewwidget.h>                 // View Widget
 #include <glxmedia.h>
 #include <glxnavigationalstate.h>
 #include <mpxcollectionpath.h>
 #include <glxcollectionpluginimageviewer.hrh>
 #include "glxfullscreenbusyicon.h"
 using namespace Alf;
 const TInt KGlxScreenTimeout =10000000;
 const TInt KCoverflowDataWindowSize = 1;
 const TInt KGlxMaxSmallImageZoomLevel =150;
 * Interval delay for the periodic timer, in microseconds
 */
 const TInt KPeriodicIntervalDelay = 100000;
 //This constant is used to calculate the index of the item for which texture has to removed.
-//6 = 5(iterator value in forward or backward direction for fullscreen) + 1(focus index);
+//6 = 5(iterator value in forward or backward direction for fullscreen) + 1(focus index)
 const TInt KFullScreenIterator = 3;
 //Constant which says maximum number of fullscreen textures that we have have at a time.
 //11 = (5(5 fullscreen texture backwards)+1(fucus index texture)+5(5 fullscreen texture forwards))
 const TInt KFullScreenTextureOffset = 5;
+_LIT( KTfxResourceActivateFullScreen, "z:\\resource\\effects\\photos_fullscreen_open.fxml" );
 // ======== MEMBER FUNCTIONS ========
 // ---------------------------------------------------------------------------
 // C++ default constructor can NOT contain any code, that
 	//create the drmutility instance
 	iDrmUtility = CGlxDRMUtility::InstanceL();
 // Get object that stores the active media list registry
 iActiveMediaListRegistry = CGlxActiveMediaListRegistry::InstanceL();
-	TInt err = iHarvesterClient.Connect();
+	iMMCNotifier = CGlxMMCNotifier::NewL(*this);
-	GLX_LOG_INFO1("iHarvesterClient.Connect() err = %d",err);
-	if(err == KErrNone)
-		{
-iHarvesterClient.AddHarvesterEventObserver(*this, EHEObserverTypeMMC, 1000);
-	    }
 	if(!iPeriodic)
 		{
 		iPeriodic = CPeriodic::NewL(CActive::EPriorityStandard);
 		}
 }
 // ---------------------------------------------------------------------------
 //
 CGlxFullScreenViewImp::~CGlxFullScreenViewImp()
 {
 TRACER("CGlxFullScreenViewImp::~CGlxFullScreenViewImp");
-iHarvesterClient.Close();
+delete iMMCNotifier;
+iMMCNotifier = NULL;
 	delete iMediaListMulModelProvider;
 if(iTimer->IsActive())
 	    {
 	    iTimer->Cancel();
 	    }
 {
 iHdmiController = CGlxHdmiController::NewL();
 SetItemToHDMIL();
 }
 iScreenFurniture->SetActiveView(iViewUid);
-// create the screen furniture for touch devices
-CreateScreenFurnitureL();
 //set the ui state to off,when the Fullscreen launches
 SetUiSate(NGlxNFullScreenUIState::EUiOff);
 	GlxSetAppState::SetState(EGlxInFullScreenView);
 // create the coverflow
 CreateCoverflowWidgetL();
+// create the screen furniture for touch devices
+CreateScreenFurnitureL();
 CreateSliderWidgetL();
 iBusyIcon = CGlxFullScreenBusyIcon::NewL(*iMediaList,*iUiUtility);
 // create a zoom control
 iZoomControl = CGlxZoomControl::NewL(*this, *iMediaList,
 // hide the screen furniture
 HideUi(ETrue);
 	// Set active media list pointer, so that UPnP renderer knows about this list
 iActiveMediaListRegistry->RegisterActiveMediaList(iMediaList);
-if ( !iPeriodic->IsActive() )
+	if ( !iPeriodic->IsActive() )
-	    {
+		{
 	    iPeriodic->Start(KPeriodicStartDelay, KPeriodicIntervalDelay,
 	            TCallBack(&PeriodicCallback, static_cast<TAny*> (this)));
-	    }
+		}
+	//Set the animation effect for the coverflow widget since the animation
+	//does not work for both avkon and alf together. This can be done since the
+	//UI Screen furnitures are disabled by default while going to fullscreen.
+	//Check if the transitions are enabled from themes
+if (CAknTransitionUtils::TransitionsEnabled(
+AknTransEffect::EFullScreenTransitionsOff))
+{
+const_cast<CAlfLayout&> (iCoverFlowWidget->ContainerLayout()).SetEffectL(
+KTfxResourceActivateFullScreen);
+}
+	//Disable the status pane here as it causes flicker while animating
+CAknViewAppUi* appui = AppUi();
+if ( appui )
+{
+appui->StatusPane()->MakeVisible(EFalse);
+appui->Cba()->MakeVisible(EFalse);
+}
+	iViewWidget->show(true);
 	}
 // ---------------------------------------------------------------------------
 // Creates a coverflow widget
 0x113);
 // hide control and status pane
 iViewWidget->enableControlPane(EFalse);
 iViewWidget->enableStatusPane(EFalse);
 iViewWidget->setRect(TRect(TPoint(0, 0), AlfUtil::ScreenSize()));
-iViewWidget->show(true);
 // create coverflow widget
 iCoverFlowWidget = widgetFactory.createWidget<IMulCoverFlowWidget> (
 KWidgetName, KCoverflowWidget, *iViewWidget, NULL);
 iCoverFlowWidget->SetFlags(IMulMultiItemWidget::EMulWidgetDoubleTap);
 // Widget takes the ownership
 iCoverFlowWidget->AddEventHandler(*this);
-CAknViewAppUi* appui = AppUi();
-if ( appui )
-{
-appui->StatusPane()->MakeVisible(EFalse);
-appui->Cba()->MakeVisible(EFalse);
-}
-iCoverFlowWidget->ShowWidget(ETrue);
 iCoverFlowWidget->control()->AcquireFocus();
 iMediaListMulModelProvider = CGlxMediaListMulModelProvider::NewL(
 *iEnv, *iCoverFlowWidget, *iMediaList, iFullScreenBindingSet,
 mulwidget::KTemplate4, KCoverflowDataWindowSize);
 TInt error = GlxErrorManager::HasAttributeErrorL(item.Properties(), KGlxMediaIdThumbnail);
 TBool isDrmRightsValid = ETrue;
 	if(item.IsDrmProtected())
 		{
-		//Fix for ESLM-82WJ59: Since it is always for the focused item - use DisplayRightsL instead of openrightsL
+		//Since it is always for the focused item - use DisplayItemRightsCheckL instead of ItemRightsValidityCheckL
-		isDrmRightsValid = iDrmUtility->CheckDisplayRightsL(item.Uri(), (item.Category() == EMPXImage));
+		isDrmRightsValid = iDrmUtility->DisplayItemRightsCheckL(item.Uri(),
+				(item.Category() == EMPXImage));
 		}
 // Display slider only for non corrupted images and items with valid DRM license
 if (error == KErrNone && item.Category() == EMPXImage && isDrmRightsValid)
 {
 }
 // hide the softkeys
 Cba()->MakeVisible( EFalse );
 Cba()->DrawNow();
-// Hide the metapane
-//iSingleLineMetaPane->ShowMetaPane(EFalse);
 // set the ui state to On
 SetUiSate(NGlxNFullScreenUIState::EUiOff);
 }
 TRACER("CGlxFullScreenViewImp::CreateScreenFurnitureL");
 // create the softkeys
 CEikButtonGroupContainer* cba = CEikButtonGroupContainer::Current();
 CleanupStack::PushL( cba );
 cba->SetCommandSetL(R_GLX_FULLSCREEN_SOFTKEYS);
-// hide the softkeys
-cba->MakeVisible( EFalse );
-cba->DrawNow();
 CleanupStack::Pop(cba);
 }
 // ---------------------------------------------------------------------------
 // SetUiSate
 // Check if DRM rights expired for a specific media item
 TBool isDrmRightsValid = ETrue;
 if(item.IsDrmProtected())
 	{
-	 //Fix for ESLM-82WJ59: DRM Rights validity check for displayed item
+	 //DRM Rights validity check for displayed item
-	isDrmRightsValid = iDrmUtility->CheckDisplayRightsL(item.Uri(), (item.Category() == EMPXImage));
+	isDrmRightsValid = iDrmUtility->DisplayItemRightsCheckL(item.Uri(),
+				(item.Category() == EMPXImage));
 	}
 // Activate Zoom if the item is an image and its DRM rights is not expired
 if(KErrNone == error && (EMPXImage == item.Category()) && isDrmRightsValid)
 {
 if(iZoomControl && !iZoomControl->Activated())
 // ---------------------------------------------------------------------------
 //
 void CGlxFullScreenViewImp::DoMLViewDeactivate()
 {
 TRACER("CGlxFullScreenViewImp::DoMLViewDeactivate");
-//Fix for ESLM-82WJ59: Clear the last uri for which DRM Rights were consumed before going back to grid view
+//Clear the last uri for which DRM Rights were consumed before going back to grid view
 //since the GridView::Activate() and FullScreen::DeActivate() can be called in any order,
 //this call is being made to be on safer side
-iDrmUtility->ClearLastConsumedItemUri();
+iDrmUtility->ClearLastConsumedItemUriL();
 iScreenFurniture->ViewDeactivated(iViewUid);
 iImgViewerMode = EFalse;
 if (iHdmiController)
 {
 delete iHdmiController;
 //
 void CGlxFullScreenViewImp::HandleForegroundEventL(TBool aForeground)
 {
 TRACER("CGlxFullScreenViewImp::HandleForegroundEventL");
 CAknView::HandleForegroundEventL(aForeground);
+if(iMMCState)
+{
+iMMCState =EFalse;
+NavigateToMainListL();
+}
 if(iZoomControl && iZoomControl->Activated())
 {
 iZoomControl->HandleZoomForegroundEvent(aForeground);
 }
 TRACER("CGlxFullScreenViewImp::CallPeriodicCallback");
 TRAP_IGNORE(ShowDrmExpiaryNoteL());
 }
 // ---------------------------------------------------------------------------
-//
+// Shows expiry note / Consumes DRM rights for expired DRM files
-// Shows expiry note/dialog for expired DRM files, can leave
 // ---------------------------------------------------------------------------
 //
 void CGlxFullScreenViewImp::ShowDrmExpiaryNoteL()
 	{
-	TRACER("CGlxFullScreenViewImp::ShowDrmExpiaryNoteL");
+TRACER("CGlxFullScreenViewImp::ShowDrmExpiaryNoteL");
-	if(iMediaList->Count()>0)
+if (iMediaList->Count() > 0)
-		{
+{
 const TGlxMedia& media = iMediaList->Item(iMediaList->FocusIndex());
 TInt tnError = GlxErrorManager::HasAttributeErrorL(
 media.Properties(), KGlxMediaIdThumbnail);
 GLX_LOG_INFO1("CGlxFullScreenViewImp::ShowDrmExpiaryNoteL()"
 " tnError=%d ", tnError);
-TSize tnSize = iUiUtility->DisplaySize();
+if (media.IsDrmProtected())
-TMPXAttribute qtyTnAttrib = TMPXAttribute(KGlxMediaIdThumbnail,
+{
-GlxFullThumbnailAttributeId(ETrue, tnSize.iWidth,
+GLX_LOG_INFO("CGlxFullScreenViewImp::ShowDrmExpiaryNoteL()"
-tnSize.iHeight));
+"- ConsumeDRMRightsL()");
-const CGlxThumbnailAttribute* qtyTn = media.ThumbnailAttribute(
+ConsumeDRMRightsL(media);
-qtyTnAttrib);
+}
-if (qtyTn)
+if (tnError == KErrNone)
 {
 if (iPeriodic->IsActive())
 {
 iPeriodic->Cancel();
 }
 }
-if (tnError == KErrNone && qtyTn && media.IsDrmProtected())
+TMPXGeneralCategory cat = media.Category();
-{
+TBool checkViewRights = (cat == EMPXImage);
-GLX_LOG_INFO("CGlxFullScreenViewImp::ShowDrmExpiaryNoteL()"
+if (iDrmUtility->ItemRightsValidityCheckL(media.Uri(),
-"- ConsumeDRMRightsL()");
+checkViewRights) && tnError != KErrNone)
-const TDesC& uri = media.Uri();
-ConsumeDRMRightsL(uri);
-}
-if (tnError != KErrNone)
 {
 if (iPeriodic->IsActive())
 {
 iPeriodic->Cancel();
 }
 GlxGeneralUiUtilities::ShowErrorNoteL(tnError);
 }
 CleanupStack::PopAndDestroy(naviState);
 CleanupStack::PopAndDestroy(navigationalState);
 }
 }
-	}
+}
 // ---------------------------------------------------------------------------
-//
+// Consumes DRM rights / Shows DRM rights (if expired) information
-// consumes DRM rights for DRM files, can leave
+// for DRM files
 // ---------------------------------------------------------------------------
 //
-void CGlxFullScreenViewImp::ConsumeDRMRightsL( const TDesC& uri )
+void CGlxFullScreenViewImp::ConsumeDRMRightsL(const TGlxMedia& aMedia)
 {
 TRACER("CGlxFullScreenViewImp::ConsumeDRMRightsL");
-if( uri.Length() > 0 )
+const TDesC& uri = aMedia.Uri();
+if (uri.Length() > 0)
 {
 // check if rights have expired
-TBool expired = !iDrmUtility->CheckOpenRightsL(uri,ETrue);
+TBool expired = !iDrmUtility->ItemRightsValidityCheckL(uri, ETrue);
-if(expired)
+if (expired)
 {
-			iBusyIcon->ShowBusyIconL(EFalse);
+if (iPeriodic->IsActive())
+{
+iPeriodic->Cancel();
+}
+iBusyIcon->ShowBusyIconL(EFalse);
 iDrmUtility->ShowRightsInfoL(uri);
 return;
 }
-iDrmUtility->ConsumeRightsL(uri);
-}
+TSize tnSize = iUiUtility->DisplaySize();
+TMPXAttribute qtyTnAttrib = TMPXAttribute(KGlxMediaIdThumbnail,
+GlxFullThumbnailAttributeId(ETrue, tnSize.iWidth,
+tnSize.iHeight));
+const CGlxThumbnailAttribute* qtyTn = aMedia.ThumbnailAttribute(
+qtyTnAttrib);
+TInt tnError = GlxErrorManager::HasAttributeErrorL(
+aMedia.Properties(), KGlxMediaIdThumbnail);
+GLX_LOG_INFO1("CGlxFullScreenViewImp::ConsumeDRMRightsL()"
+" tnError=%d ", tnError);
+if (qtyTn && tnError == KErrNone)
+{
+if (iPeriodic->IsActive())
+{
+iPeriodic->Cancel();
+}
+GLX_LOG_INFO("CGlxFullScreenViewImp::ConsumeDRMRightsL()"
+"- ConsumeRights");
+iDrmUtility->ConsumeRightsL(uri);
+}
+}
 }
 // ---------------------------------------------------------------------------
 //
 // Gets the Swipe direction
 GLX_LOG_INFO1("CGlxFullScreenViewImp::GetSwipeDirection()"
 " Direction = [%d] ", swipedirection);
 return swipedirection;
 }
 // ---------------------------------------------------------------------------
 //
 // Gets the index of the item for which the texture has to be removed
 // ---------------------------------------------------------------------------
 //
 }
 }
 GLX_LOG_INFO1("CGlxFullScreenViewImp::GetIndexToBeRemoved index tobe removed %d",indextoberemoved );
 return indextoberemoved;
 }
 // ---------------------------------------------------------------------------
 //
 // Remove the texture on every swipe while HDMI is connected.
 // ---------------------------------------------------------------------------
 //
 // or if HDMI is not connected
 // or if there is no HDMI Controller at all
 // then dont SetImageToHDMI :)
 if( ( KErrNotFound == focusIndex)
 || (0 == iMediaList->Count())
-|| (NULL == iHdmiController)
+|| (NULL == iHdmiController))
-|| (!iHdmiController->IsHDMIConnected()))
 {
 GLX_LOG_INFO("CGlxFullScreenViewImp::SetImageToHDMIL - Cant Set Image To HDMI");
 return;
 }
 // Item will be supported by HDMI ONLY if
 // it is not a video
 // and it has valid DRM Viewing rights
 // and it has no attribute error
 if ( (item.Category() != EMPXVideo)
-&& iDrmUtility->CheckOpenRightsL(item.Uri(), ETrue)
+&& iDrmUtility->ItemRightsValidityCheckL(item.Uri(), ETrue)
 && (error == KErrNone) )
 {
 GLX_LOG_INFO("CGlxFullScreenViewImp::SetImageToHDMIL - CGlxHdmi - Setting the Image");
-TInt frameCount(0);
+iHdmiController->SetImageL(item.Uri());
-TSize orignalSize;
-item.GetFrameCount(frameCount);
-item.GetDimensions(orignalSize);
-iHdmiController->SetImageL(item.Uri(), orignalSize, frameCount);
 }
 else
 {
 GLX_LOG_INFO("CGlxFullScreenViewImp::SetImageToHDMIL - Unsupported Item");
 //Set the external display to cloning mode if
 //the current item is something we dont support
-//(e.g. video, corrupted item, item with invalid DRM);
+//(e.g. video, corrupted item, item with invalid DRM)
 iHdmiController->ItemNotSupported();
 }
 iOldFocusIndex = iMediaList->FocusIndex();
 }
-// ---------------------------------------------------------------------------
-// HarvestingUpdated
+// ---------------------------------------------------------------------------
+// HandleMMCInsertionL
 //
 // ---------------------------------------------------------------------------
-//
+void CGlxFullScreenViewImp::HandleMMCInsertionL()
-void CGlxFullScreenViewImp::HarvestingUpdated(
+{
-HarvesterEventObserverType HarvestingUpdated,
+TRACER("CGlxFullScreenViewImp::HandleMMCInsertionL()");
-HarvesterEventState aHarvesterEventState,
+iMMCState = ETrue;
-TInt aItemsLeft )
+NavigateToMainListL();
-{
+}
-TRACER("CGlxFullScreenViewImp::HarvestingUpdated()");
-if(HarvestingUpdated == EHEObserverTypeMMC)
+// ---------------------------------------------------------------------------
+// NavigateToMainListL
+//
+// ---------------------------------------------------------------------------
+void CGlxFullScreenViewImp::NavigateToMainListL()
+{
+TRACER("CGlxFullScreenViewImp::NavigateToMainListL()");
+CGlxNavigationalState* navigationalState =  CGlxNavigationalState::InstanceL();
+CleanupClosePushL( *navigationalState );
+CMPXCollectionPath* naviState = navigationalState->StateLC();
+if (naviState->Id() != TMPXItemId(KGlxCollectionPluginImageViewerImplementationUid))
 {
 if(iZoomControl && iZoomControl->Activated())
 	{
 	SetSliderLevel();
 		    DeactivateZoomControlL();
 	}
 ProcessCommandL(EAknSoftkeyClose);
 }
-}
+CleanupStack::PopAndDestroy(naviState);
+CleanupStack::PopAndDestroy(navigationalState);
+}
+// ---------------------------------------------------------------------------
+// HandleMMCInsertionL
+//
+// ---------------------------------------------------------------------------
+void CGlxFullScreenViewImp::HandleMMCRemovalL()
+{
+TRACER("CGlxFullScreenViewImp::HandleMMCRemovalL()");
+if(iZoomControl && iZoomControl->Activated())
+{
+SetSliderLevel();
+DeactivateZoomControlL();
+}
+ProcessCommandL(EAknSoftkeyExit);
+}

branch	RCL_3
changeset 13	bcb43dc84c44
parent 12	ce1c7ad1f18b
child 14	2dac0fdba72b