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

equal deleted inserted replaced

-:71da52165949
+:ce1c7ad1f18b
 #include <gesturehelper.h>
 using namespace GestureHelper;
-//Hg
-//#include <hg/hgcontextutility.h>
 #include <glxhdmicontroller.h>
 // Photos Headers
 #include <glxlog.h>                             // CGlxLogger
 #include <glxtracer.h>                          // For Log
 #include <glxmedialistmulmodelprovider.h>       // For MulModelProvider
 #include <glxcommandhandlers.hrh>               // For EGlxCmdFullScreenBack
 #include <glxfullscreenviewdata.rsg>            // FS View Resource
 #include <glxthumbnailattributeinfo.h>          // KGlxMediaIdThumbnail
-//#include "glxmediakeyutility.h"
 #include <glxactivemedialistregistry.h>         // For medialist registry
 #include <glxerrormanager.h>
 #include <glxzoomcontrol.h>
 #include <glxuiutilities.rsg>
 #include <glxgeneraluiutilities.h>
 #include <glxtexturemanager.h>
 #include <glxicons.mbg>
 #include <glxsetappstate.h>
 #include <glxdrmutility.h>
 #include <glxscreenfurniture.h>
-//#include <glxsinglelinemetapanecontrol.h>
 #include "glxfullscreenviewimp.h"
 #include <glxnavigationalstate.h>
 #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;
 	//create the drmutility instance
 	iDrmUtility = CGlxDRMUtility::InstanceL();
 // Get object that stores the active media list registry
 iActiveMediaListRegistry = CGlxActiveMediaListRegistry::InstanceL();
-if(!iPeriodic)
+	TInt err = iHarvesterClient.Connect();
+	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");
-delete iMediaListMulModelProvider;
+iHarvesterClient.Close();
+	delete iMediaListMulModelProvider;
 if(iTimer->IsActive())
 	    {
 	    iTimer->Cancel();
 	    }
 	delete iTimer;
 		   	{
 		   	navigationalState->SetToViewMode();
 		   	}
 		}
 if(naviState->Id() == TMPXItemId(KGlxCollectionPluginImageViewerImplementationUid))
 {
 iImgViewerMode = ETrue;
 }
 //destroy and close navistate and navipath
 CleanupStack::PopAndDestroy( naviState );
 CleanupStack::PopAndDestroy( navigationalState );
 //Create hdmicontroller when it is only launched from fullscreen.
 //From filemanager show only clone mode.
-if(!iImgViewerMode && iMediaList->Count())
+if( !iImgViewerMode )
 {
 iHdmiController = CGlxHdmiController::NewL();
-iOldFocusIndex = iMediaList->FocusIndex();
+SetItemToHDMIL();
-SetImageL();
 }
 iScreenFurniture->SetActiveView(iViewUid);
 // create the screen furniture for touch devices
 CreateScreenFurnitureL();
 	GlxSetAppState::SetState(EGlxInFullScreenView);
 // create the coverflow
 CreateCoverflowWidgetL();
 CreateSliderWidgetL();
-//    iMediaKeyUtility = CGlxMediaKeyUtility::NewL();
+iBusyIcon = CGlxFullScreenBusyIcon::NewL(*iMediaList,*iUiUtility);
 // create a zoom control
 iZoomControl = CGlxZoomControl::NewL(*this, *iMediaList,
 *iZoomButtonGroup, *iSliderWidget, iGestureHelper);
-// Create the Metapane
-//iSingleLineMetaPane = CGlxSingleLineMetaPane::NewL(*this,*iMediaList,*iUiUtility);
 // hide the screen furniture
 HideUi(ETrue);
 	// Set active media list pointer, so that UPnP renderer knows about this list
 iActiveMediaListRegistry->RegisterActiveMediaList(iMediaList);
-//Get the HgContextUtility instance
+if ( !iPeriodic->IsActive() )
-//    iContextUtility = iUiUtility->ContextUtility();
+	    {
+	    iPeriodic->Start(KPeriodicStartDelay, KPeriodicIntervalDelay,
-// if the Medialist has any item, set the First index context to Hg Context Utility
+	            TCallBack(&PeriodicCallback, static_cast<TAny*> (this)));
-//    TGlxMedia item = iMediaList->Item( iMediaList->FocusIndex() );
+	    }
-//    iContextUtility->PublishPhotoContextL(item.Uri());
-	if ( !iPeriodic->IsActive() )
-		{
-iPeriodic->Start(KPeriodicStartDelay, KPeriodicIntervalDelay,
-TCallBack(&PeriodicCallback, static_cast<TAny*> (this)));
-		}
 	}
 // ---------------------------------------------------------------------------
 // Creates a coverflow widget
 //adding the range and slider tick value
 if(iSliderModel)
 {
 iSliderModel->SetTick(KGlxSliderTickValue);
 }
-//SetSliderLevel();
 }
 catch(...)
 {
 User::Leave(KErrGeneral);
 }
 TInt error = GlxErrorManager::HasAttributeErrorL(item.Properties(), KGlxMediaIdThumbnail);
 TBool isDrmRightsValid = ETrue;
 	if(item.IsDrmProtected())
 		{
-		isDrmRightsValid = iDrmUtility->CheckOpenRightsL(item.Uri(),
+		//Fix for ESLM-82WJ59: Since it is always for the focused item - use DisplayRightsL instead of openrightsL
-												(item.Category() == EMPXImage));
+		isDrmRightsValid = iDrmUtility->CheckDisplayRightsL(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)
 {
 // For floating toolbar in non-touch devices
 iScreenFurniture->SetToolbarVisibility(ETrue);
 //show the softkeys
 Cba()->MakeVisible( ETrue );
 Cba()->DrawNow();
-// Show the Metapane
-//iSingleLineMetaPane->ShowMetaPane(ETrue);
 //set the ui state to On
 SetUiSate(NGlxNFullScreenUIState::EUiOn);
 //start the timer,for the screen timeout
 // Check if DRM rights expired for a specific media item
 TBool isDrmRightsValid = ETrue;
 if(item.IsDrmProtected())
 	{
-	isDrmRightsValid = iDrmUtility->CheckOpenRightsL(item.Uri(),
+	 //Fix for ESLM-82WJ59: DRM Rights validity check for displayed item
-												(item.Category() == EMPXImage));
+	isDrmRightsValid = iDrmUtility->CheckDisplayRightsL(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())
 {
 if(iHdmiController)
 {
-iHdmiController->ActivateZoom();
+TBool autoZoomOut = ETrue;
+//Set autozoomout to false in pinch zoom, since we would be
+//zooming out on deactivate once we get the release event.
+if(aStartMode == EZoomStartPinch)
+{
+autoZoomOut = EFalse;
+}
+iHdmiController->ActivateZoom(autoZoomOut);
 }
 iZoomControl->ActivateL(GetInitialZoomLevel(),aStartMode, focus,
 item, apZoomFocus,iImgViewerMode);
 // Now to remove all textures other than the one we are focussing on.
 TInt count = iMediaList->Count();
 // ---------------------------------------------------------------------------
 //
 void CGlxFullScreenViewImp::DeactivateZoomControlL()
 {
 TRACER("CGlxFullScreenViewImp::DeactivateZoomControlL");
 ActivateFullScreenL();
+//Deactivate HDMI controller for zoom out while pinch zooming.
+if(iHdmiController)
+{
+iHdmiController->DeactivateZoom();
+}
 if(iZoomControl->Activated())
 {
 iZoomControl->Deactivate();
 }
 //Once into fullscreen view,show the screen furniture
 HideUi(ETrue);
 }
 // ---------------------------------------------------------------------------
 //
 void CGlxFullScreenViewImp::DoMLViewDeactivate()
 {
 TRACER("CGlxFullScreenViewImp::DoMLViewDeactivate");
-// if Medialist Count is Zero, set the navigation state to
+//Fix for ESLM-82WJ59: Clear the last uri for which DRM Rights were consumed before going back to grid view
-// EGlxNavigationBackwards before going back to grid view
+//since the GridView::Activate() and FullScreen::DeActivate() can be called in any order,
-if(iMediaList->Count() == 0)
+//this call is being made to be on safer side
-	{
+iDrmUtility->ClearLastConsumedItemUri();
-	iUiUtility->SetViewNavigationDirection(EGlxNavigationBackwards);
-	}
 iScreenFurniture->ViewDeactivated(iViewUid);
 iImgViewerMode = EFalse;
 if (iHdmiController)
 {
 delete iHdmiController;
 {
 GLX_LOG_INFO("CGlxFullScreenViewImp::OfferEventL ETypeDoubleTap");
 MulDoubleTapData* DoubleTapData = (MulDoubleTapData*)(aEvent.CustomEventData());
 TPoint doubleTapPoint = DoubleTapData->mDoubleTapPoint;
-SetSliderLevel();
+TInt focus = iMediaList->FocusIndex();
-TRAP_IGNORE( ActivateZoomControlL(EZoomStartDoubleTap, &doubleTapPoint) );
+TGlxMedia item = iMediaList->Item( focus );
+TSize size;
+item.GetDimensions( size );
+TRect rect = AlfUtil::ScreenSize();
+TInt zoomLevel = GetInitialZoomLevel();
+TInt tlX = (rect.Width() - (size.iWidth*zoomLevel)/100)/2;
+TInt tlY = (rect.Height() - (size.iHeight*zoomLevel)/100)/2;
+TRect imageRect(TPoint(tlX, tlY), TSize((size.iWidth*zoomLevel)/100, (size.iHeight*zoomLevel)/100));
+if (imageRect.Contains(doubleTapPoint))
+{
+SetSliderLevel();
+TRAP_IGNORE( ActivateZoomControlL(EZoomStartDoubleTap, &doubleTapPoint)  );
+}
 return EEventConsumed;
 }
 case ETypeItemRemoved:
 {
-if(iHdmiController)
+SetItemToHDMIL();
-{
-SetImageL();
-}
-iOldFocusIndex = iMediaList->FocusIndex();
 return EEventConsumed;
 }
 case ETypeHighlight:
 {
 iMediaList->SetFocusL( NGlxListDefs::EAbsolute,(aEvent.CustomEventData()));
 	}
 if(iMediaList->Count()> KFullScreenTextureOffset)
 {
 RemoveTexture();
 }
-if(iHdmiController)
+SetItemToHDMIL();
-{
-SetImageL();
-}
-iOldFocusIndex = iMediaList->FocusIndex();
 if ( NGlxNFullScreenUIState::EUiOn == GetUiSate() )
 {
 HideUi(ETrue);
 }
 TRAP_IGNORE(ShowDrmExpiaryNoteL());
 }
 return EEventConsumed; // will be consumed even if we are pinching IN (trying to zoom OUT).
 //slider event handling
 case ETypePrimaryValueChange:
 {
-// Zoomview is only launched if the currentslider value is above the level
-// of fullscreenlevel.
 iTimer->Cancel();
 iSliderWidget->ShowWidget( ETrue, 0 );
-TRAP_IGNORE( ActivateZoomControlL(EZoomStartSlider));
+TRAPD( err, ActivateZoomControlL(EZoomStartSlider));
+if (err != KErrNone)
+{
+iSliderModel->SetPrimaryValue(GetInitialZoomLevel());
+}
 }
 return EEventConsumed;
 default:
 return EEventNotHandled;
 }
 		    DeactivateZoomControlL();
 		    consumed = ETrue;
 		    break;
 		case EGlxCmdRenameCompleted:
 		    {
-if (iHdmiController)
+SetItemToHDMIL();
-{
-SetImageL();
-}
 			consumed = ETrue;
 break;
 }
-//		case EGlxCmdRotateLeft:
-//			iCoverFlowWidget->RotateImage(IMulWidget::ERotateLeft,size,KGlxRotationDelay);
-//		    consumed = ETrue;
-//		    break;
-//		case EGlxCmdRotateRight:
-//		    iCoverFlowWidget->RotateImage(IMulWidget::ERotateRight,size,KGlxRotationDelay);
-//            consumed = ETrue;
-//            break;
 }
 return consumed;
 }
 // ---------------------------------------------------------------------------
 {
 // check if rights have expired
 TBool expired = !iDrmUtility->CheckOpenRightsL(uri,ETrue);
 if(expired)
 {
+			iBusyIcon->ShowBusyIconL(EFalse);
 iDrmUtility->ShowRightsInfoL(uri);
 return;
 }
 iDrmUtility->ConsumeRightsL(uri);
 }
 }
 else
 {
 swipedirection = (focusindex-iOldFocusIndex < 0 ? EBackward : EForward) ;
 }
-return swipedirection;
+GLX_LOG_INFO1("CGlxFullScreenViewImp::GetSwipeDirection()"
+" Direction = [%d] ", swipedirection);
+return swipedirection;
 }
 // ---------------------------------------------------------------------------
 //
 // Gets the index of the item for which the texture has to be removed
 // ---------------------------------------------------------------------------
 TRACER("CGlxFullScreenViewImp::RemoveTexture");
 const TGlxMedia& item = iMediaList->Item(GetIndexToBeRemoved());
 iUiUtility->GlxTextureManager().RemoveTexture(item.Id(),EFalse);
 }
 // ---------------------------------------------------------------------------
 //
 // Set the image to external display - HDMI
 // ---------------------------------------------------------------------------
 //
-void CGlxFullScreenViewImp::SetImageL()
+void CGlxFullScreenViewImp::SetItemToHDMIL()
 {
-TRACER("CGlxFullScreenViewImp::SetImageL - CGlxHdmi");
+TRACER("CGlxFullScreenViewImp::SetImageToHDMIL - CGlxHdmi");
-TGlxMedia item = iMediaList->Item(iMediaList->FocusIndex());
+TInt focusIndex = iMediaList->FocusIndex();
+// If we dont know what item we are focussing on
+// or if out medialist is empty
+// 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)
+|| (!iHdmiController->IsHDMIConnected()))
+{
+GLX_LOG_INFO("CGlxFullScreenViewImp::SetImageToHDMIL - Cant Set Image To HDMI");
+return;
+}
+TGlxMedia item = iMediaList->Item(focusIndex);
 TInt error = GlxErrorManager::HasAttributeErrorL(item.Properties(),
 KGlxMediaIdThumbnail);
-if (item.Category() != EMPXVideo && iDrmUtility->CheckOpenRightsL(
-item.Uri(), ETrue) && (error == KErrNone))
+// 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)
+&& (error == KErrNone) )
+{
+GLX_LOG_INFO("CGlxFullScreenViewImp::SetImageToHDMIL - CGlxHdmi - Setting the Image");
 TInt frameCount(0);
 TSize orignalSize;
-TBool aFramesPresent = item.GetFrameCount(frameCount);
+item.GetFrameCount(frameCount);
-TBool adimension = item.GetDimensions(orignalSize);
+item.GetDimensions(orignalSize);
 iHdmiController->SetImageL(item.Uri(), orignalSize, frameCount);
-GLX_LOG_INFO("CGlxFullScreenViewImp::SetImageL - CGlxHdmi - calling SetImage");
 }
 else
 {
-GLX_LOG_INFO("CGlxFullScreenViewImp::SetImageL - CGlxHdmi - calling IsVideo");
+GLX_LOG_INFO("CGlxFullScreenViewImp::SetImageToHDMIL - Unsupported Item");
-//Set the external display to cloning mode.
+//Set the external display to cloning mode if
-//If the current item is a video, corruted thumbnail
+//the current item is something we dont support
-iHdmiController->IsVideo();
+//(e.g. video, corrupted item, item with invalid DRM);
-}
+iHdmiController->ItemNotSupported();
 }
+iOldFocusIndex = iMediaList->FocusIndex();
+}
+// ---------------------------------------------------------------------------
+// HarvestingUpdated
+//
+// ---------------------------------------------------------------------------
+//
+void CGlxFullScreenViewImp::HarvestingUpdated(
+HarvesterEventObserverType HarvestingUpdated,
+HarvesterEventState aHarvesterEventState,
+TInt aItemsLeft )
+{
+TRACER("CGlxFullScreenViewImp::HarvestingUpdated()");
+if(HarvestingUpdated == EHEObserverTypeMMC)
+{
+if(iZoomControl && iZoomControl->Activated())
+	{
+	SetSliderLevel();
+		    DeactivateZoomControlL();
+	}
+ProcessCommandL(EAknSoftkeyClose);
+}
+}

branch	RCL_3
changeset 14	ce1c7ad1f18b
parent 13	71da52165949
child 18	bcb43dc84c44