diff -r 000000000000 -r 4e91876724a2 photosgallery/slideshow/view/src/shwslideshowview.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/photosgallery/slideshow/view/src/shwslideshowview.cpp Thu Dec 17 08:45:44 2009 +0200 @@ -0,0 +1,1296 @@ +/* +* Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Implementation of Slideshow view +* +*/ + + + + + +// INCLUDE FILES +#include +#include "shwslideshowview.h" + +#include +#include // for access to CEikButtonGroupContainer (from Cba()) +#include // for CompleteWithAppPath +#include +#include + +#include +#include +#include +#include +#include + +//Hg +//#include +#include +#include // for CGlxResourceUtilities +#include // for CGlxResolutionUtility +#include // view's resource +#include // for resource directory path +#include +#include +#include // for CAknKeySoundSystem +#include // for R_AVKON_SILENT_SKEY_LIST +#include +#include +#include +#include "mpxcollectionutility.h" +#include "glxfilterfactory.h" // for TGlxFilterFactory +#include "mglxmedialist.h" +#include "glxuiutility.h" +#include "shwslideshowengine.h" +#include "shweffectinfo.h" +#include "shwslideshowvolumecontrol.h" +#include "shwslideshowbacklighttimer.h" +#include "shwslideshowview.hrh" // for EShwSlideshowCmdContinue +#include "shwslideshowkeyhandler.h" +#include "shwslideshowpausehandler.h" +#include "shwslideshowtelephonehandler.h" +#include "shwcallback.h" +#include "shwsettingsmodel.h" +#include "shwgesturecontrol.h" +#include "shwviewtimer.h" +#include "shwmediakeyshandler.h" +#include +namespace + { + _LIT(KShwSlideshowViewResource,"shwslideshowview.rsc"); + const TInt KShwDefaultDelayMicroSeconds = 5000000; // 5s + const TInt KVolumeControlGroupId = 1; + // Reuse the plug-in's uid + const TInt KViewId = 0x20007199; + //gontrol goup id has to be locally unique + const TInt KShwGestureControlGroupId = 2; + const TInt KGestureControlGroupId = 44; + //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); + const TInt KSlideShowIterator = 2; + //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 KSlideShowTextureOffset = 3; + } +//display screen furniture for KShowForSeconds +const TInt KShowForSeconds = 5; + +// ======== MEMBER FUNCTIONS ======== + +// --------------------------------------------------------------------------- +// Default constructor. Inlined to save a few bits of ROM +// --------------------------------------------------------------------------- +// +inline CShwSlideshowView::CShwSlideshowView() : + CGlxViewBase(ETrue) // workaround - force synchronous view activation + { + TRACER("CShwSlideshowView::CShwSlideshowView"); + GLX_LOG_INFO( "CShwSlideshowView::CShwSlideshowView" ); + } + +// --------------------------------------------------------------------------- +// Two-phased constructor. +// --------------------------------------------------------------------------- +// +CShwSlideshowView* CShwSlideshowView::NewLC() + { + TRACER("CShwSlideshowView::NewLC"); + GLX_LOG_INFO( "CShwSlideshowView::NewLC" ); + CShwSlideshowView* self = new ( ELeave ) CShwSlideshowView; + CleanupStack::PushL( self ); + self->ConstructL(); + return self; + } + +// --------------------------------------------------------------------------- +// Destructor +// --------------------------------------------------------------------------- +// +CShwSlideshowView::~CShwSlideshowView() + { + TRACER("CShwSlideshowView::~CShwSlideshowView"); + GLX_LOG_INFO( "CShwSlideshowView::~CShwSlideshowView()" ); + + // delete media list population call back + delete iPopulateListCallBack; + + // delete engine async starter + delete iAsyncCallBack; + + // Cleanup both the lists in case view was not deactivated + if ( iMediaList ) + { + iMediaList->Close(); + } + + if ( iFilteredList ) + { + iFilteredList->Close(); + } + + // Remove the back light timer + delete iBackLightTimer; + + // Delete the control groups + if ( iEnv ) + { + iEnv->DeleteControlGroup( KVolumeControlGroupId ); + iVolumeControlGroup = NULL; + if(iGestureControlGroup) + { + CAlfControl* gesture = (&(iGestureControlGroup->Control(1))); // CGestureControl is 1 + iGestureControlGroup->Remove(gesture); + } + iEnv->DeleteControlGroup( KShwGestureControlGroupId ); + iGestureControlGroup = NULL; + delete iGestureControl; + } + + // Turn back on the keypad tones + AppUi()->KeySounds()->PopContext(); + + // Delete resource file + if ( iResourceOffset ) + { + CCoeEnv::Static()->DeleteResourceFile( iResourceOffset ); + iResourceOffset = NULL; + } + } + +// ----------------------------------------------------------------------------- +// ShowProgressDialogL. +// ----------------------------------------------------------------------------- +TInt CShwSlideshowView::ShowProgressDialogL() + { + TRACER("CShwSlideshowView::ShowProgressDialogL"); + GLX_LOG_INFO( "CShwSlideshowView::ShowProgressDialogL" ); + + // Set to landscape orientation + // Note that the orientation switch is performed here rather than in the + // view activation to ensure the correct use of the screen furniture layout + iUiUtility->SetAppOrientationL( EGlxOrientationLandscape ); + // Set display background as a solid black colour + iDisplay->SetClearBackgroundL( CAlfDisplay::EClearWithColor ); + + // Setup the progress dialog + iWaitDialog = new ( ELeave ) CAknWaitDialog( + reinterpret_cast< CEikDialog** >( &iWaitDialog ), ETrue ); + iWaitDialog->PrepareLC( R_SHW_WAIT_NOTE ); + // Dialog is non-modal so request dismissal callbacks + iWaitDialog->SetCallback( this ); + // Load string for dialog + HBufC* title = StringLoader::LoadLC( R_SHW_WAIT_DLG_OPENING ); + iWaitDialog->SetTextL( *title ); + CleanupStack::PopAndDestroy( title ); + + // Show the dialog, we show it non blocking so no use for the return value + iWaitDialog->RunLD(); + // set the callback to be engine start + iAsyncCallBack->Set( + TShwCallBack< CShwSlideshowView, StartEngineL >( this ) ); + // if both lists are ready + if( iInputListReady && iPlayListReady ) + { + // make the async callback, this will end up calling StartEngineL() + // in CAsyncCallback::RunL once the scheduler next time runs. + iAsyncCallBack->CallBack(); + } + + // return value needed as this is a TCallBack + return KErrNone; + } + +// ----------------------------------------------------------------------------- +// StartEngineL +// ----------------------------------------------------------------------------- +TInt CShwSlideshowView::StartEngineL() + { + TRACER("CShwSlideshowView::StartEngineL"); + GLX_LOG_INFO( "CShwSlideshowView::StartEngineL" ); + // Check that the list has some items + if( iFilteredList ) + { + TInt filteredCount = iFilteredList->Count(); + TInt inputlistCount = iMediaList->Count(); + if ( ( inputlistCount < 1 )|| + ( filteredCount < 1 ) ) + { + GLX_LOG_INFO2( + "CShwSlideshowView::PopulateListL error, counts: %d, %d", + inputlistCount, filteredCount ); + iEngineStartFailed = ETrue; + // need to dismiss the dialog if it's still there + if( iWaitDialog ) + { + iWaitDialog->ProcessFinishedL(); + } + } + else + { + // The list should now be populated, so set the focus + SetListFocusL(); + // Need to take latest screen size as layout has changed + TRect currentScreen; + TSize screenSize; + AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EScreen,currentScreen); + screenSize = currentScreen.Size(); + iEngine->StartL( + *iEnv, *iDisplay, *iFilteredList, *this, screenSize ); + } + } + // return value needed as this is a TCallBack + return KErrNone; + } + +// ----------------------------------------------------------------------------- +// PopulateListL +// ----------------------------------------------------------------------------- +TInt CShwSlideshowView::PopulateListL() + { + TRACER("CShwSlideshowView::PopulateListL"); + GLX_LOG_INFO( "CShwSlideshowView::PopulateListL" ); + // Setup a filter given the play direction and the path + CMPXFilter* filter = NULL; + + // take current filter and add the slideshow parameters in it + // If we play forwards, we dont revert the original order and if we + // play backwards we need to just revert the original order + // Note we dont know the original order and cant ask for it as its set by the + // 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(); + // create the filter + filter = TGlxFilterFactory::CreateSlideShowFilterFromExistingFilterL( + iMediaList->Filter(), fullpath, + iPlayDirection); + CleanupStack::PushL( filter ); + + // Use this DLL's uid as the hierarchy id + 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; + } + +// --------------------------------------------------------------------------- +// Symbian 2nd phase constructor can leave. +// --------------------------------------------------------------------------- +// +void CShwSlideshowView::ConstructL() + { + TRACER("CShwSlideshowView::ConstructL"); + GLX_LOG_INFO( "CShwSlideshowView::ConstructL()" ); + + // Load the view's resources + TFileName resourceFile( KDC_APP_RESOURCE_DIR ); + resourceFile.Append( KShwSlideshowViewResource ); + CGlxResourceUtilities::GetResourceFilenameL( resourceFile ); + iResourceOffset = iCoeEnv->AddResourceFileL( resourceFile ); + + // AknView base construction + BaseConstructL( R_SHW_SLIDESHOW_PLAY_VIEW ); + + // Glx view base construction + ViewBaseConstructL(); + + // Create async engine starter with standard priority + iAsyncCallBack = new( ELeave ) CAsyncCallBack( CActive::EPriorityStandard ); + + // Create the back light timer + iBackLightTimer = CShwSlideshowBackLightTimer::NewL(); + + iEnv = iUiUtility->Env(); + iDisplay = iUiUtility->Display(); + + // Construct the volume control + iVolumeControl = CShwSlideshowVolumeControl:: + NewL( *iEnv, + *iUiUtility, + KShwDefaultDelayMicroSeconds ); + // Create a control group for the volume control + iVolumeControlGroup = &iEnv->NewControlGroupL( KVolumeControlGroupId ); + // doc says the following takes ownership, but reality is different! + iVolumeControlGroup->AppendL( iVolumeControl ); + + iGestureControlGroup = &iEnv->NewControlGroupL( KShwGestureControlGroupId ); + + // construct the gesture control group + iShwGestureControl = CShwGestureControl::NewL(*iEnv,*iDisplay,*this); + iGestureControlGroup->AppendL( iShwGestureControl ); + + iGestureControl = GestureHelper::CGestureControl::NewLC( + *iShwGestureControl, *iEnv, *iDisplay, KGestureControlGroupId ); + iGestureControlGroup->AppendL( iGestureControl ); + + // doc says the following takes ownership, but reality is different! + + CleanupStack::Pop( iGestureControl ); + // Need a mechanism to distinguish when we receive the MusicVolume + // callback for the first time + iCurrentVolume = -1; + iPopulateListCallBack = new( ELeave ) + CAsyncCallBack( CActive::EPriorityStandard ); + // set the callback for the media list population + iPopulateListCallBack->Set( + TShwCallBack< CShwSlideshowView, PopulateListL >( this ) ); + iMSKPressed = EFalse; + iLSKPressed = EFalse; + + //Get the HgContextUtility instance +// iContextUtility = iUiUtility->ContextUtility(); + + } + +// --------------------------------------------------------------------------- +// From CAknView +// Returns views id. +// --------------------------------------------------------------------------- +// +TUid CShwSlideshowView::Id() const + { + TRACER("CShwSlideshowView::Id()"); + GLX_LOG_INFO( "CShwSlideshowView::Id()" ); + return TUid::Uid( KViewId ); + } + +// --------------------------------------------------------------------------- +// From CAknView +// Foreground event handling function. +// --------------------------------------------------------------------------- +// +void CShwSlideshowView::HandleForegroundEventL(TBool aForeground) + { + TRACER("CShwSlideshowView::HandleForegroundEventL"); + GLX_LOG_INFO( "CShwSlideshowView::HandleForegroundEventL()" ); + + if( aForeground ) + { + // we gained the foreground + iPauseHandler->SwitchToForegroundL(); + } + else + { + // Something else has gained the foreground + iPauseHandler->SwitchToBackgroundL(); + } + + CAknView::HandleForegroundEventL(aForeground); + } + +// ----------------------------------------------------------------------------- +// From CGlxViewBase +// DoViewActivateL. +// ----------------------------------------------------------------------------- +void CShwSlideshowView::DoViewActivateL(const TVwsViewId& /*aPrevViewId*/, + TUid /*aCustomMessageId*/, + const TDesC8& aCustomMessage) + { + TRACER("CShwSlideshowView::DoViewActivateL"); + GLX_LOG_INFO( "CShwSlideshowView::DoViewActivateL()" ); + + // remove the status pane + AppUi()->StatusPane()->MakeVisible(EFalse); + + //make the softkeys invisible + AppUi()->Cba()->MakeVisible(EFalse); + + // Hide the application toolbar when slide show is started + if ( AppUi()->PopupToolbar() ) + { + AppUi()->PopupToolbar()->SetToolbarVisibility( EFalse ); + AppUi()->PopupToolbar()->MakeVisible(EFalse); + } + // reset failure flag + iEngineStartFailed = EFalse; + + iHdmiController = CGlxHdmiController::NewL(); + // Engine related construction + // Instantiate the slideshow engine, with this class as its observer + __ASSERT_DEBUG( !iEngine, Panic( EGlxPanicAlreadyInitialised ) ); + iEngine = CShwSlideshowEngine::NewL( *this ); + + // Instantiate the pause handler, it encapsulates the pause rules + __ASSERT_DEBUG( !iPauseHandler, Panic( EGlxPanicAlreadyInitialised ) ); + iPauseHandler = CShwSlideShowPauseHandler::NewL( *iEngine ); + + // Instantiate the key handler, encapsulates all key handling logic + __ASSERT_DEBUG( !iKeyHandler, Panic( EGlxPanicAlreadyInitialised ) ); + iKeyHandler = CShwSlideShowKeyHandler::NewL( *iEngine, *iPauseHandler, + reinterpret_cast(iShwState )); + AppUi()->AddToStackL( iKeyHandler, ECoeStackPriorityDefault, + ECoeStackFlagRefusesFocus ); + + // Create the telephone call handler + __ASSERT_DEBUG( !iTelephoneHandler, Panic( EGlxPanicAlreadyInitialised ) ); + iTelephoneHandler = CShwTelephoneHandler::NewL( *iEngine, *iPauseHandler ); + iTelephoneHandler->StartL(); + + // Extract the media list's path and the playback direction from + // the custom message data + GetPathAndPlaybackDirectionL( aCustomMessage ); + + // Ensure the back light stays on + iBackLightTimer->StartL(); + + // Request asynch callback that will end up in ShowProgressDialogL + // once the active scheduler runs + iAsyncCallBack->Set( + TShwCallBack< CShwSlideshowView, ShowProgressDialogL >( this ) ); + iAsyncCallBack->CallBack(); + + iDisplay->Roster().ShowL( *iGestureControlGroup,KAlfRosterShowAtTop ); + + iTicker = CShwTicker::NewL(*this); + + InitializeShwFurnitureL(); + iUiUtility->Display()->SetVisibleArea(TRect(TPoint(0,0),AlfUtil::ScreenSize())); + } + +// ----------------------------------------------------------------------------- +// From CGlxViewBase +// DoViewDeactivate. +// ----------------------------------------------------------------------------- +void CShwSlideshowView::DoViewDeactivate() + { + TRACER("CShwSlideshowView::DoViewDeactivate"); + GLX_LOG_INFO( "CShwSlideshowView::DoViewDeactivate()" ); + if (iHdmiController) + { + GLX_LOG_INFO( "CShwSlideshowView::DoViewDeactivate() - delete hdmicontroller" ); + delete iHdmiController; + iHdmiController = NULL; + } + + //check if we have engine active object starting + if( iPopulateListCallBack->IsActive() ) + { + //cancel the engine start + iPopulateListCallBack->Cancel(); + } + + //check if we have engine active object starting + if( iAsyncCallBack->IsActive() ) + { + //cancel the engine start + iAsyncCallBack->Cancel(); + } + + //Hide the volume control group, iDisplay and iVolumeControlGroup + //are always valid so no need to test for != NULL + iDisplay->Roster().Hide( *iVolumeControlGroup ); + + + //Ensure we revert to a proper background + TRAP_IGNORE( + { + iDisplay->SetClearBackgroundL( CAlfDisplay::EClearWithSkinBackground ); + } ); + + + //Ensure we don't get any more key events + AppUi()->RemoveFromStack( iKeyHandler ); + delete iKeyHandler; + iKeyHandler = NULL; + + //Stop handling telephone calls + delete iTelephoneHandler; + iTelephoneHandler = NULL; + + //delete the pause handler + //it is used by key and telephone handlers so do this last + delete iPauseHandler; + iPauseHandler = NULL; + + //Cancel the back light timer + iBackLightTimer->Cancel(); + + + //Stop the slideshow! + //NOTE! this needs to be done before the list is closed as the + //destructor removes the engine as medialist observer and also + //removes the contexts from the list + delete iEngine; + iEngine = NULL; + + delete iCollectionPath; + iCollectionPath = NULL; + + //Ensure we don't get any more list callbacks + if( iMediaList ) + { + iMediaList->RemoveMediaListObserver( this ); + //need to close the list + iMediaList->Close(); + //set to NULL to prevent double delete + iMediaList = NULL; + } + //Ensure we don't get any more list callbacks + if ( iFilteredList ) + { + iFilteredList->RemoveMediaListObserver( this ); + //need to also close the list + iFilteredList->Close(); + //set to NULL to prevent double delete + iFilteredList = NULL; + } + iDisplay->Roster().Hide( *iGestureControlGroup ); + + if(iTicker) + { + delete iTicker; + iTicker =NULL; + } + AppUi()->RemoveFromStack( iShwCba ); + delete iShwCba; + iShwCba =NULL; + if(iMediaKeyHandler) + { + delete iMediaKeyHandler; + iMediaKeyHandler = NULL; + } + } + +// --------------------------------------------------------------------------- +// From MGlxMediaListObserver +// HandleItemAddedL +// --------------------------------------------------------------------------- +// +void CShwSlideshowView::HandleItemAddedL( TInt /*aStartIndex*/, + TInt /*aEndIndex*/, + MGlxMediaList* /*aList*/ ) + { + } + +// --------------------------------------------------------------------------- +// From MGlxMediaListObserver +// HandleMediaL +// --------------------------------------------------------------------------- +// +void CShwSlideshowView::HandleMediaL( TInt /*aListIndex*/, + MGlxMediaList* /*aList*/) + { + } + +// --------------------------------------------------------------------------- +// From MGlxMediaListObserver +// HandleItemRemoved +// --------------------------------------------------------------------------- +// +void CShwSlideshowView::HandleItemRemovedL( TInt /*aStartIndex*/, + TInt /*aEndIndex*/, + MGlxMediaList* /*aList*/ ) + { + } + +// --------------------------------------------------------------------------- +// From MGlxMediaListObserver +// HandleItemModifiedL. +// --------------------------------------------------------------------------- +// +void CShwSlideshowView::HandleItemModifiedL( + const RArray& /*aItemIndexes*/, MGlxMediaList* /*aList*/ ) + { + } + +// --------------------------------------------------------------------------- +// From MGlxMediaListObserver +// HandleAttributesAvailableL. +// --------------------------------------------------------------------------- +// +void CShwSlideshowView::HandleAttributesAvailableL( + TInt /*aItemIndex*/, + const RArray& /*aAttributes*/, + MGlxMediaList*/* aList*/ ) + { + } + +// --------------------------------------------------------------------------- +// From MGlxMediaListObserver +// HandleFocusChangedL. +// --------------------------------------------------------------------------- +// +void CShwSlideshowView::HandleFocusChangedL( NGlxListDefs::TFocusChangeType /*aType*/, + TInt /*aNewIndex*/, + TInt /*aOldIndex*/, + MGlxMediaList* /*aList*/) + { + TRACER("CShwSlideshowView::HandleFocusChangedL()"); + if(iFilteredList) + { + if (iFilteredList->Count() && iHdmiActive) + { + if(iFilteredList->Count() > KSlideShowTextureOffset) + { + RemoveTexture(); + } + SetImage(); + } + } + } + +// --------------------------------------------------------------------------- +// From MGlxMediaListObserver +// HandleItemSelected. +// --------------------------------------------------------------------------- +// +void CShwSlideshowView::HandleItemSelectedL( TInt /*aIndex*/, + TBool /*aSelected*/, + MGlxMediaList* /*aList*/) + { + } + +// --------------------------------------------------------------------------- +// From MGlxMediaListObserver +// HandleMessageL. +// --------------------------------------------------------------------------- +// +void CShwSlideshowView::HandleMessageL( const CMPXMessage& /*aMessage*/, + MGlxMediaList* /*aList*/) + { + } + +// --------------------------------------------------------------------------- +// From MGlxMediaListObserver +// HandlePopulated. +// --------------------------------------------------------------------------- +// +void CShwSlideshowView::HandlePopulatedL( MGlxMediaList* aList ) + { + TRACER("CShwSlideshowView::HandlePopulatedL"); + GLX_LOG_INFO( "CShwSlideshowView::HandlePopulatedL" ); + + if( iMediaList == aList ) + { + // input list is ready + iInputListReady = ETrue; + // read the selection and filter + // note that these cannot be read until the list has been populated + // make the async callback, this will end up calling PopulateListL() + // in CAsyncCallback::RunL once the scheduler next time runs. + iPopulateListCallBack->CallBack(); + } + else if( iFilteredList == aList ) + { + // playable list is ready + iPlayListReady = ETrue; + } + + // the filtered list has been populated so start the engine + if( iInputListReady && iPlayListReady ) + { + // make the async callback, this will end up calling StartEngineL() + // in CAsyncCallback::RunL once the scheduler next time runs. + // this is a no-op if the callback is already active + iAsyncCallBack->CallBack(); + } + } + +// --------------------------------------------------------------------------- +// From MShwEngineObserver +// Engine started callback. +// --------------------------------------------------------------------------- +// +void CShwSlideshowView::EngineStartedL() + { + TRACER("CShwSlideshowView::EngineStartedL"); + GLX_LOG_INFO( "CShwSlideshowView::EngineStartedL()" ); + + if ( iWaitDialog ) + { + // cancel the progress bar + iWaitDialog->ProcessFinishedL(); + } + iShwState = EShwPlay; + ReplaceCommandSetL(R_SHW_SOFTKEYS_END_PAUSE,R_SHW_SOFTKEYS_END_PAUSE); + ShowShwFurnitureL(); + } + +// --------------------------------------------------------------------------- +// From MShwEngineObserver +// Engine paused callback. +// --------------------------------------------------------------------------- +// +void CShwSlideshowView::EnginePausedL() + { + TRACER("CShwSlideshowView::EnginePausedL"); + GLX_LOG_INFO( "CShwSlideshowView::EnginePausedL()" ); + + // Cancel the backlight if it's on + if ( iBackLightTimer->IsRunning() ) + { + iBackLightTimer->Cancel(); + } + + if(!iUiUtility->IsExitingState()) + { + iShwState = EShwPause; + ReplaceCommandSetL(R_SHW_SOFTKEYS_END_CONTINUE,R_SHW_SOFTKEYS_END_PAUSE); + ShowShwFurnitureL(); + } + } + +// --------------------------------------------------------------------------- +// From MShwEngineObserver +// Engine resumed callback. +// --------------------------------------------------------------------------- +// +void CShwSlideshowView::EngineResumedL() + { + TRACER("CShwSlideshowView::EngineResumedL"); + GLX_LOG_INFO( "CShwSlideshowView::EngineResumedL" ); + // Re-enable the backlight if it's off + if ( !iBackLightTimer->IsRunning() ) + { + iBackLightTimer->StartL(); + } + iShwState = EShwPlay; + ReplaceCommandSetL(R_SHW_SOFTKEYS_END_PAUSE,R_SHW_SOFTKEYS_END_CONTINUE); + ShowShwFurnitureL(); + } +// --------------------------------------------------------------------------- +// From MShwEngineObserver +// Engine LSK Pressed +// --------------------------------------------------------------------------- +// +void CShwSlideshowView::EngineLSKPressedL() + { + TRACER("CShwSlideshowView::EngineLSKPressedL"); + GLX_LOG_INFO( "CShwSlideshowView::EngineLSKPressedL" ); + iLSKPressed = ETrue; + iPauseHandler->UserToggledPauseL(); + } +// --------------------------------------------------------------------------- +// From MShwEngineObserver +// Engine Toggle Ui callback.EngineLSKPressedL +// --------------------------------------------------------------------------- +// +void CShwSlideshowView::EngineToggleUiStateL() + { + TRACER("CShwSlideshowView::EngineToggleUiStateL"); + GLX_LOG_INFO( "CShwSlideshowView::EngineToggleUiStateL" ); + iMSKPressed = ETrue; + if(iShwFurniture == EFurnitureVisible) + { + HideShwFurniture(); + } + else + { + ShowShwFurnitureL(); + } + } + +// --------------------------------------------------------------------------- +// From MShwEngineObserver +// Engine encountered an error and we need to exit. +// --------------------------------------------------------------------------- +void CShwSlideshowView::ErrorDuringSlideshowL() + { + TRACER("CShwSlideshowView::ErrorDuringSlideshowL"); + GLX_LOG_INFO( "CShwSlideshowView::ErrorDuringSlideshowL" ); + iEngineStartFailed = ETrue; + // need to dismiss the dialog if it's still there + if( iWaitDialog ) + { + iWaitDialog->ProcessFinishedL(); + } + else + { + ProcessCommandL( EAknSoftkeyBack ); + } + } + +// ----------------------------------------------------------------------------- +// From MShwMusicObserver +// MusicOn. +// ----------------------------------------------------------------------------- +void CShwSlideshowView::MusicOnL() + { + TRACER("CShwSlideshowView::MusicOnL"); + GLX_LOG_INFO( "CShwSlideshowView::MusicOnL" ); + // Turn on the keypad tones + AppUi()->KeySounds()->PushContextL( R_AVKON_SILENT_SKEY_LIST ); + // if MusicOn leaves, MusicOff will get called + // initialize the medikey control only if music is on. + // delayed initialization intended + // since there is a conflict if slideshow is launched from full screen + iMediaKeyHandler = CShwMediaKeyUtility::NewL(); + } + +// ----------------------------------------------------------------------------- +// From MShwMusicObserver +// MusicOff. +// ----------------------------------------------------------------------------- +void CShwSlideshowView::MusicOff() + { + TRACER("CShwSlideshowView::MusicOff"); + GLX_LOG_INFO( "CShwSlideshowView::MusicOff" ); + // + TInt resource_id = AppUi()->KeySounds()->TopContext(); + if( R_AVKON_SILENT_SKEY_LIST == resource_id ) + { + // Turn off the keypad tones + AppUi()->KeySounds()->PopContext(); + } + + // If it's visible, hide the volume control + iDisplay->Roster().Hide( *iVolumeControlGroup ); + //delete the media key handler + if(iMediaKeyHandler) + { + delete iMediaKeyHandler; + iMediaKeyHandler = NULL; + } + } + +// ----------------------------------------------------------------------------- +// From MShwMusicObserver +// MusicVolume. +// ----------------------------------------------------------------------------- +void CShwSlideshowView::MusicVolumeL(TInt aCurrentVolume, TInt aMaxVolume) + { + TRACER("CShwSlideshowView::MusicVolume"); + GLX_LOG_INFO( "CShwSlideshowView::MusicVolume" ); + if (aCurrentVolume != iCurrentVolume) + { + // Store the changed value + iCurrentVolume = aCurrentVolume; + iVolumeControl->SetVolume(aCurrentVolume, aMaxVolume); + } + // Always show the control even if the volume hasn't changed, e.g. @ 100% + iVolumeControl->RefreshL(); + } + +// ----------------------------------------------------------------------------- +// From MShwMusicObserver +// ErrorWithTrackL. +// ----------------------------------------------------------------------------- +void CShwSlideshowView::ErrorWithTrackL( TInt /*aErrorCode*/ ) + { + TRACER("CShwSlideshowView::ErrorWithTrackL"); + // we dont use the error code as any kind of error with track file + // means we cannot play it. + // set the music to off if there was an error in track (file missing etc) + // this way the user gets notification only once + // ER: EMSR-77PCSJ + CShwSettingsModel* shwSettingsMdl = CShwSettingsModel::NewL(); + CleanupStack::PushL( shwSettingsMdl ); + shwSettingsMdl->SaveMusicStateL( EFalse ); + CleanupStack::PopAndDestroy( shwSettingsMdl ); + + // Display the error note + HBufC* noteBuf = StringLoader::LoadLC( + R_SHW_QTN_LGAL_NOTE_SLIDESHOW_DEFINE ); + CAknInformationNote* note = new (ELeave) CAknInformationNote; + CleanupStack::Pop( noteBuf ); + note->ExecuteLD( *noteBuf ); + } + +// ----------------------------------------------------------------------------- +// From MProgressDialogCallback +// Gets called when a dialog is dismissed. +// ----------------------------------------------------------------------------- +void CShwSlideshowView::DialogDismissedL( TInt aButtonId ) + { + TRACER("CShwSlideshowView::DialogDismissedL"); + GLX_LOG_INFO( "CShwSlideshowView::DialogDismissedL" ); + if ( iEngineStartFailed || aButtonId == EEikBidCancel ) + { + // Cancel the callback + iAsyncCallBack->Cancel(); + // Send the back command to return to the previous view + ProcessCommandL( EAknSoftkeyBack ); + } + } + +// ----------------------------------------------------------------------------- +// SetupScreenFurnitureL. +// ----------------------------------------------------------------------------- +void CShwSlideshowView::SetupScreenFurnitureL() + { + TRACER("CShwSlideshowView::SetupScreenFurnitureL"); + GLX_LOG_INFO( "CShwSlideshowView::SetupScreenFurnitureL" ); + // Create the soft keys + // Left (bottom in landscape orientation) + HBufC* softKeyTextLeft = StringLoader::LoadLC( R_SHW_SOFTKEY_LEFT ); + // SetSoftKeyL takes ownership of softKeyText + //SetSoftkeyL( EGlxLeftSoftkey, EShwSlideshowCmdContinue, softKeyTextLeft ); + CleanupStack::Pop( softKeyTextLeft ); + // Right (top in landscape orientation) + HBufC* softKeyTextRight = StringLoader::LoadLC( R_SHW_SOFTKEY_RIGHT ); + // SetSoftKeyL takes ownership of softKeyText + //SetSoftkeyL( EGlxRightSoftkey, EAknSoftkeyBack, softKeyTextRight ); + CleanupStack::Pop( softKeyTextRight ); + + } + +// ----------------------------------------------------------------------------- +// GetPathAndPlaybackDirectionL +// ----------------------------------------------------------------------------- +void CShwSlideshowView::GetPathAndPlaybackDirectionL( const TDesC8& aData ) + { + TRACER("CShwSlideshowView::GetPathAndPlaybackDirectionL"); + GLX_LOG_INFO( "CShwSlideshowView::GetPathAndPlaybackDirectionL" ); + // reset state flags for list population + iInputListReady = iPlayListReady = EFalse; + + // 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 ); + iPlayDirection = 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 + iMediaList = MGlxMediaList::InstanceL( *iCollectionPath ); + // the list might be already populated + if( iMediaList->IsPopulated() ) + { + iInputListReady = ETrue; + // list is ready so read the selection and filter already now + // need to do this while on DoViewActivateL as the previous view + // may loose the selection while it is closing + PopulateListL(); + } + else + { + // add us as an observer for the input list as well + // we cannot read the path and filter before the list is populated + iMediaList->AddMediaListObserverL( this ); + } + + CleanupStack::PopAndDestroy( &stream ); + } + +// ----------------------------------------------------------------------------- +// SetListFocusL. +// ----------------------------------------------------------------------------- +void CShwSlideshowView::SetListFocusL() + { + TRACER("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 ) + { + // nothing selected, so determine which item has focus in the original list + focusIndex = iMediaList->FocusIndex(); + const TGlxMedia& mediaItem = iMediaList->Item( focusIndex ); + // is this item in the filtered list? + TGlxIdSpaceId spaceId = iMediaList->IdSpaceId( focusIndex ); + focusIndex = iFilteredList->Index( spaceId, mediaItem.Id() ); + if ( focusIndex == KErrNotFound ) + { + // it's been filtered out so just use the first item + focusIndex = 0; + } + } + iFilteredList->SetFocusL( NGlxListDefs::EAbsolute, focusIndex ); + SetImage(); + iHdmiActive = ETrue; +// iContextUtility->PublishPhotoContextL(item.Uri()); + } + + +// ----------------------------------------------------------------------------- +// HandleTickL. +// act on timer expiry +// ----------------------------------------------------------------------------- +// +void CShwSlideshowView::HandleTickL() + { + TRACER("CShwSlideshowView::HandleTickL"); + GLX_LOG_INFO( "CShwSlideshowView::HandleTickL" ); + if(iShwFurniture != EFurnitureVisible) + { + ShowShwFurnitureL(); + } + else + { + HideShwFurniture(); + } + } + +// ----------------------------------------------------------------------------- +// HandleTickCancelled. +// act on timer cancelled +// ----------------------------------------------------------------------------- +// +void CShwSlideshowView::HandleTickCancelled() + { + + } + +// ----------------------------------------------------------------------------- +// HandleShwGestureEventL. +// act on gestures +// ----------------------------------------------------------------------------- +// +void CShwSlideshowView::HandleShwGestureEventL(MShwGestureObserver::TShwGestureEventType aType) + { + TRACER("CShwSlideshowView::HandleShwGestureEventL"); + GLX_LOG_INFO( "CShwSlideshowView::HandleShwGestureEventL" ); + iTicker->CancelTicking(); + switch(aType) + { + case ETapEvent: + { + if(iShwFurniture == EFurnitureVisible) + { + HideShwFurniture(); + } + else + { + ShowShwFurnitureL(); + } + break; + } + case ESwipeLeft: + { + iEngine->NextItemL(); + break; + } + case ESwipeRight: + { + iEngine->PreviousItemL(); + break; + } + default: + { + break; + } + } + } +// ----------------------------------------------------------------------------- +// InitializeShwFurnitureL. +// set sof keys and the volume slider +// ----------------------------------------------------------------------------- +// +void CShwSlideshowView::InitializeShwFurnitureL() + { + TRACER("CShwSlideshowView::InitializeShwFurnitureL"); + GLX_LOG_INFO( "CShwSlideshowView::InitializeShwFurnitureL" ); + // initialize softkeys + InitializeCbaL(); + } + +// ----------------------------------------------------------------------------- +// InitializeCbaL. +// set sof keys +// ----------------------------------------------------------------------------- +// +void CShwSlideshowView::InitializeCbaL() + { + TRACER("CShwSlideshowView::InitializeCbaL"); + GLX_LOG_INFO( "CShwSlideshowView::InitializeCbaL" ); + // initialize with the end-pause command set as that is the one + // we are supposed to show immediately on slideshow play + // orientation: set to Vertical as slide show is always intended to + // run in landscape mode + 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 +// ----------------------------------------------------------------------------- +// +void CShwSlideshowView::ReplaceCommandSetL(TInt aNewComandId, TInt aOldCommandSet) + { + TRACER("CShwSlideshowView::ReplaceCommandSetL"); + GLX_LOG_INFO( "CShwSlideshowView::ReplaceCommandSetL" ); + //find and remove the command set + TInt pos = iShwCba->PositionById( aOldCommandSet ); + if( pos != KErrNotFound ) + { + iShwCba->RemoveCommandFromStack( pos, aOldCommandSet ); + } + // set the new command set + iShwCba->SetCommandSetL( aNewComandId ); + // keep the current active command set + iCurrentActiveCommandSet = aNewComandId; + } + + +// ----------------------------------------------------------------------------- +// HideShwFurnitureL. +// hide softkeys and the volume slider +// ----------------------------------------------------------------------------- +// +void CShwSlideshowView::HideShwFurniture() + { + TRACER("CShwSlideshowView::HideShwFurnitureL"); + GLX_LOG_INFO( "CShwSlideshowView::HideShwFurnitureL" ); + iTicker->CancelTicking(); + iShwCba->MakeVisible(EFalse); + iShwCba->DrawNow(); + if(iMediaKeyHandler) + { + iVolumeControl->Hide(); + } + iShwFurniture = EFurnitureHidden; + + } + +// ----------------------------------------------------------------------------- +// ShowShwFurnitureL. +// show softkeys and the volume slider +// ----------------------------------------------------------------------------- +// +void CShwSlideshowView::ShowShwFurnitureL() + { + TRACER("CShwSlideshowView::ShowShwFurnitureL"); + GLX_LOG_INFO( "CShwSlideshowView::ShowShwFurnitureL" ); + iTicker->CancelTicking(); + iShwCba->MakeVisible(ETrue); + iShwCba->DrawNow(); + if(iMediaKeyHandler) + { + iVolumeControl->ShowControlL(); + } + iShwFurniture = EFurnitureVisible; + //start the timer to keep the up the screen furniture for 5 seconds + iTicker->StartTicking(KShowForSeconds); + } + +// ----------------------------------------------------------------------------- +// ProcessCommandL. +// handle softkey events +// ----------------------------------------------------------------------------- +// +void CShwSlideshowView::ProcessCommandL(TInt aCommandId) + { + TRACER("CShwSlideshowView::ProcessCommandL"); + GLX_LOG_INFO( "CShwSlideshowView::ProcessCommandL" ); + switch(aCommandId) + { + case EShwSlideshowCmdEnd: + { + iShwState = EShwExiting; + aCommandId = EAknSoftkeyBack; + iDisplay->Roster().Hide( *iGestureControlGroup ); + 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) + { + iMSKPressed = EFalse; + } + else if(iLSKPressed) + { + iLSKPressed = EFalse;// Already Handlled + } + else + { + iPauseHandler->UserToggledPauseL(); + } + break; + } + + default: + { + break; + } + } + CGlxViewBase::ProcessCommandL(aCommandId); + } +// ----------------------------------------------------------------------------- +// SetImage. +// To set Image to external display if HDmi connected +// ----------------------------------------------------------------------------- +// +void CShwSlideshowView::SetImage() + { + TRACER("CShwSlideshowView::SetImage"); + TGlxMedia item = iFilteredList->Item( iFilteredList->FocusIndex() ); + TInt frameCount(0); + TSize orignalSize; + TBool aFramesPresent = item.GetFrameCount(frameCount); + TBool adimension = item.GetDimensions(orignalSize); + iHdmiController->SetImageL(item.Uri(), orignalSize, frameCount); + } +// --------------------------------------------------------------------------- +// +// Gets the index of the item for which the texture has to be removed +// --------------------------------------------------------------------------- +// +TInt CShwSlideshowView::GetIndexToBeRemoved() + { + TRACER("CShwSlideshowView::GetIndexToBeRemoved"); + TInt indextoberemoved; + TInt count = iFilteredList->Count(); + TInt focusIndex = iFilteredList->FocusIndex(); + if(iPlayDirection == NShwSlideshow::EPlayForwards) + { + indextoberemoved = focusIndex-KSlideShowIterator; + if(indextoberemoved < 0) + { + indextoberemoved = count+indextoberemoved; + } + } + else + { + indextoberemoved = focusIndex+KSlideShowIterator; + if(indextoberemoved > count-1) + { + indextoberemoved = indextoberemoved-count; + } + } + GLX_LOG_INFO1("CShwSlideshowView::GetIndexToBeRemoved Index to be removed is %d",indextoberemoved); + return indextoberemoved; + } +// --------------------------------------------------------------------------- +// +// Remove the texture on every swipe while HDMI is connected. +// --------------------------------------------------------------------------- +// +void CShwSlideshowView::RemoveTexture() + { + TRACER("CShwSlideshowView::RemoveTexture"); + const TGlxMedia& item = iFilteredList->Item(GetIndexToBeRemoved()); + iUiUtility->GlxTextureManager().RemoveTexture(item.Id(),EFalse); + }