MCL/sf/app/photos: comparison photosgallery/slideshow/view/src/shwslideshowview.cpp

equal deleted inserted replaced

-:b023a8d2866a
+:ea65f74e6de4
 #include <glxhdmicontroller.h>
 #include <glxresourceutilities.h>               // for CGlxResourceUtilities
 #include <glxresolutionutility.h>               // for CGlxResolutionUtility
 #include <shwslideshowview.rsg> // view's resource
 #include <data_caging_path_literals.hrh>	// for resource directory path
+#include <glxcommandhandlers.hrh>			// for EGlxCmdResetView
 #include <glxlog.h>
 #include <glxtracer.h>
 #include <aknsoundsystem.h>				// for CAknKeySoundSystem
 #include <avkon.rsg>					// for R_AVKON_SILENT_SKEY_LIST
 #include <mpxcollectionpath.h>
 			}
 		else
 			{
 			// The list should now be populated, so set the focus
 			SetListFocusL();
+			// Initialize control textures
+			iVolumeControl->InitControlTextureL();
 			// Need to take latest screen size as layout has changed
 			TRect currentScreen;
 			AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EScreen,
 					currentScreen);
 			iScrnSize = currentScreen.Size();
 // plug-in and never returned to the client side.
 // we need the full path for the filter creation so that the selection can be
 // extracted from there
 CMPXCollectionPath* fullpath = iMediaList->PathLC();
+// CreateSlideShowFilterFromExistingFilterL() takes ownership of the fullpath so no need to destroy it.
+CleanupStack::Pop( fullpath );
 // create the filter
 filter = TGlxFilterFactory::CreateSlideShowFilterFromExistingFilterL(
 iMediaList->Filter(), fullpath,
 iPlayDirection);
 CleanupStack::PushL( filter );
 TGlxHierarchyId hierarchyId = TUid( NShwSlideshow::KEngineDllUid ).iUid;
 iFilteredList = MGlxMediaList::InstanceL( *iCollectionPath, hierarchyId, filter );
 iFilteredList->AddMediaListObserverL( this );
 CleanupStack::PopAndDestroy( filter );
-CleanupStack::PopAndDestroy( fullpath );
 // return value needed as this is a TCallBack
 return KErrNone;
 }
 // set the callback for the media list population
 iPopulateListCallBack->Set(TShwCallBack<CShwSlideshowView,
 &CShwSlideshowView::PopulateListL> (this));
 iMSKPressed = EFalse;
 iLSKPressed = EFalse;
+iAknEventMonitor
+= static_cast<CAknAppUiBase*> (CCoeEnv::Static()->AppUi())->EventMonitor();
 }
 // ---------------------------------------------------------------------------
 // From CAknView
 // Returns views id.
 return TUid::Uid( KViewId );
 }
 // ---------------------------------------------------------------------------
 // From CAknView
-// Foreground event handling function.
+// Background event handling in HandleWsEventL.
+// Foreground event handling this function.
 // ---------------------------------------------------------------------------
 //
 void CShwSlideshowView::HandleForegroundEventL(TBool aForeground)
 {
-TRACER("CShwSlideshowView::HandleForegroundEventL");
+	TRACER("CShwSlideshowView::HandleForegroundEventL");
-	GLX_LOG_INFO( "CShwSlideshowView::HandleForegroundEventL()" );
+	GLX_LOG_INFO1("CShwSlideshowView::HandleForegroundEventL(%d)", aForeground);
 	iIsForegrnd = aForeground;
-if( aForeground )
+	if (aForeground)
 {
 if (iHdmiController && iHdmiActive)
 {
 iHdmiController->ShiftToPostingMode();
 }
 {
 iPauseHandler->SwitchToForegroundL();
 iEngine->GetMusicVolumeL();
 }
 }
-else
-{
-if (iHdmiController && iHdmiActive)
-{
-iHdmiController->ShiftToCloningMode();
-}
-// Something else has gained the foreground
-iPauseHandler->SwitchToBackgroundL();
-}
 CAknView::HandleForegroundEventL(aForeground);
 }
 // -----------------------------------------------------------------------------
 // From CGlxViewBase
 InitializeShwFurnitureL();
 iUiUtility->Display()->SetVisibleArea(TRect(TPoint(0,0),AlfUtil::ScreenSize()));
 	// We will require to act on events ONLY when the view is active.
 	// So listen to them only when the view is active.
 iShwGestureControl->AddObserverL(this);
+iAknEventMonitor->Enable(ETrue);
+iAknEventMonitor->AddObserverL(this);
 }
 // -----------------------------------------------------------------------------
 // From CGlxViewBase
 // DoViewDeactivate.
 //Hide the volume control group, iDisplay and iVolumeControlGroup
 //are always valid so no need to test for != NULL
 	iDisplay->Roster().Hide( *iVolumeControlGroup );
+iAknEventMonitor->Enable(EFalse);
+iAknEventMonitor->RemoveObserver(this);
 	//Ensure we revert to a proper background
 TRAP_IGNORE(
 {
 iDisplay->SetClearBackgroundL( CAlfDisplay::EClearWithSkinBackground );
 // From MShwEngineObserver
 // Engine started callback.
 // ---------------------------------------------------------------------------
 //
 void CShwSlideshowView::EngineStartedL()
-	{
+{
-	TRACER("CShwSlideshowView::EngineStartedL");
+TRACER("CShwSlideshowView::EngineStartedL");
-	GLX_LOG_INFO( "CShwSlideshowView::EngineStartedL()" );
+GLX_LOG_INFO( "CShwSlideshowView::EngineStartedL()" );
+if (iWaitDialog)
-	if (iWaitDialog)
+{
-		{
+// cancel the progress bar
-		// cancel the progress bar
+iWaitDialog->ProcessFinishedL();
-		iWaitDialog->ProcessFinishedL();
+}
-		}
+if (iHdmiController)
-	if (iHdmiController)
+{
-		{
+iHdmiController->ShiftToPostingMode();
-		iHdmiController->ShiftToPostingMode();
+}
-		}
+// Here, iShwState value is either 0(first instance)
-	iShwState = EShwPlay;
+// or EShwExiting(remembered from previous instance)
-	ReplaceCommandSetL(R_SHW_SOFTKEYS_END_PAUSE, R_SHW_SOFTKEYS_END_PAUSE);
+iShwState = EShwPlay;
-	ShowShwFurnitureL();
+ShowShwFurnitureL();
-	}
+}
 // ---------------------------------------------------------------------------
 // From MShwEngineObserver
 // Engine paused callback.
 // ---------------------------------------------------------------------------
 //
 void CShwSlideshowView::EnginePausedL()
 {
 TRACER("CShwSlideshowView::EnginePausedL");
-	GLX_LOG_INFO( "CShwSlideshowView::EnginePausedL()" );
+GLX_LOG_INFO( "CShwSlideshowView::EnginePausedL()" );
 // Cancel the backlight if it's on
-if ( iBackLightTimer->IsRunning() )
+if (iBackLightTimer->IsRunning())
 {
 iBackLightTimer->Cancel();
 }
+if (!iUiUtility->IsExitingState() && (iShwState != EShwExiting))
-if(!iUiUtility->IsExitingState())
+{
-	{
+iShwState = EShwPause;
-	iShwState = EShwPause;
+ReplaceCommandSetL(R_SHW_SOFTKEYS_END_CONTINUE,
-		ReplaceCommandSetL(R_SHW_SOFTKEYS_END_CONTINUE,R_SHW_SOFTKEYS_END_PAUSE);
+R_SHW_SOFTKEYS_END_PAUSE);
-	ShowShwFurnitureL();
+ShowShwFurnitureL();
-	}
+}
 }
 // ---------------------------------------------------------------------------
 // From MShwEngineObserver
 // Engine resumed callback.
 // ---------------------------------------------------------------------------
 //
 void CShwSlideshowView::EngineResumedL()
-	{
+{
-	TRACER("CShwSlideshowView::EngineResumedL");
+TRACER("CShwSlideshowView::EngineResumedL");
-	GLX_LOG_INFO( "CShwSlideshowView::EngineResumedL" );
+GLX_LOG_INFO( "CShwSlideshowView::EngineResumedL" );
-	iEngine->GetMusicVolumeL();
+iEngine->GetMusicVolumeL();
 // Re-enable the backlight if it's off
-if ( !iBackLightTimer->IsRunning() )
+if (!iBackLightTimer->IsRunning())
 {
 iBackLightTimer->StartL();
 }
-iShwState = EShwPlay;
+if (iShwState != EShwExiting)
-ReplaceCommandSetL(R_SHW_SOFTKEYS_END_PAUSE,R_SHW_SOFTKEYS_END_CONTINUE);
+{
-ShowShwFurnitureL();
+iShwState = EShwPlay;
-	}
+ReplaceCommandSetL(R_SHW_SOFTKEYS_END_PAUSE,
+R_SHW_SOFTKEYS_END_CONTINUE);
+ShowShwFurnitureL();
+}
+}
 // ---------------------------------------------------------------------------
 // From MShwEngineObserver
 // Engine LSK Pressed
 // ---------------------------------------------------------------------------
 //
 	 // Create a copy of the media list using the path and the play direction
 	RDesReadStream stream( aData );
 	CleanupClosePushL( stream );
 	stream.ReadInt32L();
 	//Get the play direction.
 	CShwSettingsModel* shwSettingsMdl = CShwSettingsModel::NewL();
-CleanupStack::PushL( shwSettingsMdl );
+	CleanupStack::PushL(shwSettingsMdl);
-iPlayDirection = static_cast< NShwSlideshow::
+	iPlayDirection
-	TPlayDirection>(shwSettingsMdl->PlayOrderL());
+			= static_cast<NShwSlideshow::TPlayDirection> (shwSettingsMdl->PlayOrderL());
 CleanupStack::PopAndDestroy( shwSettingsMdl );
 	// Retrieve the path
 	iCollectionPath = CMPXCollectionPath::NewL();
 	iCollectionPath->InternalizeL( stream );
 	// Create the media list from the path
 // SetListFocusL.
 // -----------------------------------------------------------------------------
 void CShwSlideshowView::SetListFocusL()
 {
 TRACER("CShwSlideshowView::SetListFocusL");
-	GLX_LOG_INFO( "CShwSlideshowView::SetListFocusL" );
+GLX_LOG_INFO("CShwSlideshowView::SetListFocusL");
 // Ensure that we start the slideshow from the correct image index:
 // if there are any selected images we always start from the first one,
 // otherwise we try to use the item with focus from the unfiltered list
 // so long as it hasn't been filtered out, in which case we use the first image.
 TInt selectionCount = iCollectionPath->Selection().Count();
 TInt focusIndex = 0;
-if ( selectionCount == 0 )
+if (selectionCount == 0)
 {
 // nothing selected, so determine which item has focus in the original list
 focusIndex = iMediaList->FocusIndex();
-const TGlxMedia& mediaItem = iMediaList->Item( focusIndex );
+GLX_LOG_INFO1("SlideshowView::SetListFocusL focusIndex(%d)", focusIndex);
+const TGlxMedia& mediaItem = iMediaList->Item(focusIndex);
 // Check if this item is in the filtered list
-TGlxIdSpaceId spaceId = iMediaList->IdSpaceId( focusIndex );
+TGlxIdSpaceId spaceId = iMediaList->IdSpaceId(focusIndex);
-focusIndex = iFilteredList->Index( spaceId, mediaItem.Id() );
+focusIndex = iFilteredList->Index(spaceId, mediaItem.Id());
-if ( focusIndex == KErrNotFound )
+if (focusIndex == KErrNotFound)
 {
-// it's been filtered out so just use the first item
+focusIndex = ((iPlayDirection == NShwSlideshow::EPlayBackwards)
-focusIndex = 0;
+? 0 : iFilteredList->Count() - 1);
 }
 }
-iFilteredList->SetFocusL( NGlxListDefs::EAbsolute, focusIndex );
+iFilteredList->SetFocusL(NGlxListDefs::EAbsolute, focusIndex);
 }
 // -----------------------------------------------------------------------------
 // HandleTickL.
 iShwCba = CEikButtonGroupContainer::NewL(
 CEikButtonGroupContainer::ECba,
 CEikButtonGroupContainer::EVertical,
 this, R_SHW_SOFTKEYS_END_PAUSE );
 iShwCba->MakeVisible(EFalse);
-//set the current active command set
-	ReplaceCommandSetL(R_SHW_SOFTKEYS_END_PAUSE,R_SHW_SOFTKEYS_END_PAUSE);
 	}
 // -----------------------------------------------------------------------------
 // ReplaceCommandSetL.
 // replaces a  commandset with a new one
 {
 iShwCba->RemoveCommandFromStack( pos, aOldCommandSet );
 }
 // set the new command set
 iShwCba->SetCommandSetL( aNewComandId );
-// keep the current active command set
-iCurrentActiveCommandSet = aNewComandId;
 }
 // -----------------------------------------------------------------------------
 // HideShwFurnitureL.
 	if(iMediaKeyHandler)
 	    {
 	    iVolumeControl->Hide();
 	    }
 	iShwFurniture = EFurnitureHidden;
 	}
 // -----------------------------------------------------------------------------
 // ShowShwFurnitureL.
 // show softkeys and the volume slider
 //
 void CShwSlideshowView::ProcessCommandL(TInt aCommandId)
 {
 TRACER("CShwSlideshowView::ProcessCommandL");
 GLX_LOG_INFO( "CShwSlideshowView::ProcessCommandL" );
-switch(aCommandId)
+switch (aCommandId)
 {
 case EShwSlideshowCmdEnd:
+case EAknSoftkeyBack:
+case EGlxCmdResetView:
 {
 iShwState = EShwExiting;
-aCommandId = EAknSoftkeyBack;
+iDisplay->Roster().Hide(*iGestureControlGroup);
-iDisplay->Roster().Hide( *iGestureControlGroup );
+HideShwFurniture();
+if (aCommandId == EShwSlideshowCmdEnd)
+{
+aCommandId = EAknSoftkeyBack;
+}
 break;
 }
 //When user presses MSK or LSK this cmd will Generated
 case EShwSlideshowCmdPause:
 case EShwSlideshowCmdContinue:
 {
 // If MSK preesed to toggle visibility of softekey
-if(iMSKPressed)
+if (iMSKPressed)
 {
 iMSKPressed = EFalse;
 }
-else if(iLSKPressed)
+else if (iLSKPressed)
 {
 iLSKPressed = EFalse;// Already Handlled
 }
 else
 {
 iPauseHandler->UserToggledPauseL();
 }
 break;
 }
 default:
 {
 break;
 }
 }
 void CShwSlideshowView::HandleHDMIDecodingEventL(THdmiDecodingStatus aStatus)
 	{
 	TRACER("CShwSlideshowView::HandleHDMIDecodingEventL()");
 	iEngine->HandleHDMIDecodingEventL(aStatus);
 	}
+// -------------------------------------------------------------------------------------------------
+//   CShwSlideshowView::IsAppInForegroundL()
+// -------------------------------------------------------------------------------------------------
+//
+TBool CShwSlideshowView::IsAppInForegroundL()
+{
+TRACER("CShwSlideshowView::IsAppInForegroundL()");
+TBool ret = EFalse;
+CArrayFixFlat<TInt>* wgList = new (ELeave) CArrayFixFlat<TInt> (
+iEikonEnv->WsSession().NumWindowGroups());
+CleanupStack::PushL(wgList);
+if (iEikonEnv->WsSession().WindowGroupList(0, wgList) == KErrNone)
+{
+//  Check if Photos App window group is in foreground
+ret = (iCoeEnv->RootWin().Identifier() == wgList->At(0));
+GLX_LOG_INFO2("SlideshowView::IsAppInForegroundL() ret=%d, wgId=%u",
+ret, wgList->At(0));
+}
+CleanupStack::PopAndDestroy(wgList);
+return ret;
+}
+// -------------------------------------------------------------------------------------------------
+// CShwSlideshowView::HandleWsEventL()
+// WS Events handling function
+// -------------------------------------------------------------------------------------------------
+//
+void CShwSlideshowView::HandleWsEventL(const TWsEvent& aEvent,
+CCoeControl* /*aDestination*/)
+{
+	TRACER("CShwSlideshowView::HandleWsEventL()");
+	TInt event = aEvent.Type();
+	GLX_LOG_INFO1("CShwSlideshowView::HandleWsEventL() event=%d", event);
+	// If we are sent to full background, shift to cloning mode
+	if ((event == KAknFullOrPartialForegroundLost) && !IsAppInForegroundL())
+		{
+		GLX_LOG_INFO("SlideshowView::HandleWsEventL() App is in background!");
+		if (iHdmiController && iHdmiActive)
+			{
+			iHdmiController->ShiftToCloningMode();
+			}
+		// Something else has gained the foreground
+		iPauseHandler->SwitchToBackgroundL();
+		}
+	}

branch	RCL_3
changeset 24	ea65f74e6de4
parent 21	f9e827349359