/*
* 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 <aknnotewrappers.h>
#include "shwslideshowview.h"
#include <aknViewAppUi.h>
#include <eikmenub.h> // for access to CEikButtonGroupContainer (from Cba())
#include <AknUtils.h> // for CompleteWithAppPath
#include <AknWaitDialog.h>
#include <StringLoader.h>
#include <alf/alfcontrolgroup.h>
#include <alf/alfenv.h>
#include <alf/alfdisplay.h>
#include <alf/alfutil.h>
#include <alf/alfroster.h>
#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>
#include <coeutils.h>
#include <eiksoftkeypostingtransparency.h>
#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 <glxtexturemanager.h>
#include <glxerrormanager.h>
#include <glxthumbnailattributeinfo.h>
#include <glxicons.mbg>
#include <AknIconUtils.h>
#include <glxuistd.h>
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 iMMCNotifier;
iMMCNotifier = NULL;
// 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,
&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();
// 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();
iHdmiWidth
= (iScrnSize.iWidth > iScrnSize.iHeight ? iScrnSize.iWidth
: iScrnSize.iHeight);
iHdmiHeight
= (iScrnSize.iWidth < iScrnSize.iHeight ? iScrnSize.iWidth
: iScrnSize.iHeight);
iEngine->StartL(*iEnv, *iDisplay, *iFilteredList, *this, iScrnSize);
if (iHdmiController == NULL || (iHdmiController
&& !iHdmiController->IsHDMIConnected()))
{
iEngine->HandleHDMIDecodingEventL(EHdmiDisconnected);
}
SetItemToHDMIL();
iHdmiActive = ETrue;
}
}
// 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();
// 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 );
// 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 );
// 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();
iMMCNotifier = CGlxMMCNotifier::NewL(*this);
// 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();
iGridIconSize = iUiUtility->GetGridIconSize();
// 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);
iGestureControlGroup->AppendL( iShwGestureControl );
GestureHelper::CGestureControl* gestureControl = GestureHelper::CGestureControl::NewLC(
*iShwGestureControl, *iEnv, *iDisplay, KGestureControlGroupId );
iGestureControl = gestureControl;
CleanupStack::Pop( gestureControl ); // doc says the following takes ownership, but reality is different
iGestureControlGroup->AppendL( 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,
&CShwSlideshowView::PopulateListL> (this));
iMSKPressed = EFalse;
iLSKPressed = EFalse;
iAknEventMonitor
= static_cast<CAknAppUiBase*> (CCoeEnv::Static()->AppUi())->EventMonitor();
}
// ---------------------------------------------------------------------------
// From CAknView
// Returns views id.
// ---------------------------------------------------------------------------
//
TUid CShwSlideshowView::Id() const
{
TRACER("CShwSlideshowView::Id()");
GLX_LOG_INFO( "CShwSlideshowView::Id()" );
return TUid::Uid( KViewId );
}
// ---------------------------------------------------------------------------
// From CAknView
// Background event handling in HandleWsEventL.
// Foreground event handling this function.
// ---------------------------------------------------------------------------
//
void CShwSlideshowView::HandleForegroundEventL(TBool aForeground)
{
TRACER("CShwSlideshowView::HandleForegroundEventL");
GLX_LOG_INFO1("CShwSlideshowView::HandleForegroundEventL(%d)", aForeground);
iIsForegrnd = aForeground;
if (aForeground)
{
if (iHdmiController && iHdmiActive)
{
iHdmiController->ShiftToPostingMode();
}
// we gained the foreground
if(iMMCState && iPrevNotInBackground)
{
ProcessCommandL(EAknSoftkeyClose);
}
else
{
iPauseHandler->SwitchToForegroundL();
iEngine->GetMusicVolumeL();
}
}
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);
}
iHdmiActive = EFalse;
// reset failure flag
iEngineStartFailed = EFalse;
if(!iHdmiController)
{
iHdmiController = CGlxHdmiController::NewL(*this);
}
if(!iTvConnection)
{
iTvConnection = CGlxTv::NewL( *this );
}
// 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<TInt&>(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,
&CShwSlideshowView::ShowProgressDialogL> (this));
iAsyncCallBack->CallBack();
iDisplay->Roster().ShowL( *iGestureControlGroup,KAlfRosterShowAtTop );
iTicker = CShwTicker::NewL(*this);
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.
// -----------------------------------------------------------------------------
void CShwSlideshowView::DoViewDeactivate()
{
TRACER("CShwSlideshowView::DoViewDeactivate");
GLX_LOG_INFO( "CShwSlideshowView::DoViewDeactivate()" );
if (iHdmiController)
{
GLX_LOG_INFO( "CShwSlideshowView::DoViewDeactivate() - delete hdmicontroller" );
delete iHdmiController;
iHdmiController = NULL;
}
if(iTvConnection)
{
delete iTvConnection;
iTvConnection = 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 );
iAknEventMonitor->Enable(EFalse);
iAknEventMonitor->RemoveObserver(this);
//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;
}
iShwGestureControl->RemoveObserver(this);
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<TInt>& /*aItemIndexes*/, MGlxMediaList* /*aList*/ )
{
}
// ---------------------------------------------------------------------------
// From MGlxMediaListObserver
// HandleAttributesAvailableL.
// ---------------------------------------------------------------------------
//
void CShwSlideshowView::HandleAttributesAvailableL(
TInt /*aItemIndex*/,
const RArray<TMPXAttribute>& /*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();
}
SetItemToHDMIL();
}
}
}
// ---------------------------------------------------------------------------
// 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();
}
if (iHdmiController)
{
iHdmiController->ShiftToPostingMode();
}
// Here, iShwState value is either 0(first instance)
// or EShwExiting(remembered from previous instance)
iShwState = EShwPlay;
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 != EShwExiting))
{
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" );
iEngine->GetMusicVolumeL();
// Re-enable the backlight if it's off
if (!iBackLightTimer->IsRunning())
{
iBackLightTimer->StartL();
}
if (iShwState != EShwExiting)
{
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 );
CleanupStack::Pop( softKeyTextLeft );
// Right (top in landscape orientation)
HBufC* softKeyTextRight = StringLoader::LoadLC( R_SHW_SOFTKEY_RIGHT );
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();
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);
focusIndex = iFilteredList->Index(spaceId, mediaItem.Id());
if (focusIndex == KErrNotFound)
{
focusIndex = ((iPlayDirection == NShwSlideshow::EPlayBackwards)
? 0 : iFilteredList->Count() - 1);
}
}
iFilteredList->SetFocusL(NGlxListDefs::EAbsolute, focusIndex);
}
// -----------------------------------------------------------------------------
// 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()
{
TRACER("CShwSlideshowView::HandleTickCancelled()");
}
// -----------------------------------------------------------------------------
// HandleShwGestureEventL.
// act on gestures
// -----------------------------------------------------------------------------
//
void CShwSlideshowView::HandleShwGestureEventL(MShwGestureObserver::TShwGestureEventType aType)
{
TRACER("CShwSlideshowView::HandleShwGestureEventL");
GLX_LOG_INFO( "CShwSlideshowView::HandleShwGestureEventL" );
// If there is no Engine, the vehicle is handicapped and there is no way to know
// whether it is possible for it to PROPERLY respond to events.
// So it is safer to not do so.
if (NULL == iEngine)
{
return ;
}
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);
}
// -----------------------------------------------------------------------------
// 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 );
}
// -----------------------------------------------------------------------------
// 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:
case EAknSoftkeyBack:
case EGlxCmdResetView:
{
iShwState = EShwExiting;
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)
{
iMSKPressed = EFalse;
}
else if (iLSKPressed)
{
iLSKPressed = EFalse;// Already Handlled
}
else
{
iPauseHandler->UserToggledPauseL();
}
break;
}
default:
{
break;
}
}
CGlxViewBase::ProcessCommandL(aCommandId);
}
// -----------------------------------------------------------------------------
// Set the image to external display - HDMI
// -----------------------------------------------------------------------------
//
void CShwSlideshowView::SetItemToHDMIL()
{
TRACER("CShwSlideshowView::SetImageToHDMIL() ");
TInt focusIndex = iFilteredList->FocusIndex();
TInt nextIndex = GetNextIndex();
// If we dont know what item we are focussing on
// or if our filtered list is empty
// or if HDMI is not connected
// or if there is no HDMI Controller at all
// then dont SetImageToHDMI :)
if( ( KErrNotFound == focusIndex)
|| (0 == iFilteredList->Count())
|| (NULL == iHdmiController))
{
GLX_LOG_INFO("CShwSlideshowView::SetImageToHDMIL - Cant Set Image To HDMI");
return;
}
TGlxMedia item = iFilteredList->Item(focusIndex);
TInt error = GlxErrorManager::HasAttributeErrorL(item.Properties(),
KGlxMediaIdThumbnail);
TGlxMedia nextItem = iFilteredList->Item(nextIndex);
TInt nexterror = GlxErrorManager::HasAttributeErrorL(nextItem.Properties(),
KGlxMediaIdThumbnail);
// Item will be supported by HDMI ONLY if
// it is not a video
// and it has no attribute error
if ( (item.Category() != EMPXVideo)
&& (error == KErrNone) )
{
GLX_LOG_INFO("CShwSlideshowView::SetImageToHDMIL - CGlxHdmi - Fetch FS thumbnail");
TMPXAttribute fsTnAttrib = TMPXAttribute(KGlxMediaIdThumbnail,
GlxFullThumbnailAttributeId(ETrue, iScrnSize.iWidth,
iScrnSize.iHeight));
const CGlxThumbnailAttribute* fsValue = item.ThumbnailAttribute(
fsTnAttrib);
if (fsValue)
{
GLX_LOG_INFO("CShwSlideshowView::SetImageToHDMIL - CGlxHdmi - Setting FS Bitmap");
CFbsBitmap* fsBitmap = new (ELeave) CFbsBitmap;
CleanupStack::PushL(fsBitmap);
fsBitmap->Duplicate( fsValue->iBitmap->Handle());
GLX_LOG_INFO2("CShwSlideshowView::SetImageToHDMIL - CGlxHdmi - FS Bitmap Size width=%d, height=%d",
fsBitmap->SizeInPixels().iWidth, fsBitmap->SizeInPixels().iHeight);
if(nexterror == KErrNone)
{
iHdmiController->SetImageL(item.Uri(), nextItem.Uri(), fsBitmap);
}
else
{
iHdmiController->SetImageL(item.Uri(), KNullDesC, fsBitmap);
}
CleanupStack::PopAndDestroy(fsBitmap);
}
else
{
GLX_LOG_INFO("CShwSlideshowView::SetImageToHDMIL - CGlxHdmi - Fetch Grid thumbnail");
TMPXAttribute gridTnAttrib = TMPXAttribute(KGlxMediaIdThumbnail,
GlxFullThumbnailAttributeId(ETrue, iGridIconSize.iWidth,
iGridIconSize.iHeight));
const CGlxThumbnailAttribute* gridvalue = item.ThumbnailAttribute(
gridTnAttrib);
if (gridvalue)
{
GLX_LOG_INFO("CShwSlideshowView::SetImageToHDMIL - CGlxHdmi - Setting Grid Bitmap");
CFbsBitmap* gridBitmap = new (ELeave) CFbsBitmap;
CleanupStack::PushL(gridBitmap);
gridBitmap->Duplicate( gridvalue->iBitmap->Handle());
GLX_LOG_INFO2("CShwSlideshowView::SetImageToHDMIL - CGlxHdmi - gridBitmap Size width=%d, height=%d",
gridBitmap->SizeInPixels().iWidth, gridBitmap->SizeInPixels().iHeight);
if(nexterror == KErrNone)
{
iHdmiController->SetImageL(item.Uri(), nextItem.Uri(), gridBitmap);
}
else
{
iHdmiController->SetImageL(item.Uri(), KNullDesC, gridBitmap);
}
CleanupStack::PopAndDestroy(gridBitmap);
}
else
{
GLX_LOG_INFO("CShwSlideshowView::SetImageToHDMIL - CGlxHdmi - Setting Null Bitmap");
TFileName resFile(KDC_APP_BITMAP_DIR);
resFile.Append(KGlxIconsFilename);
CFbsBitmap* defaultBitmap = AknIconUtils::CreateIconL(resFile,
EMbmGlxiconsQgn_prop_image_notcreated);
CleanupStack::PushL(defaultBitmap);
// always need to setsize on the raw bitmap for it to be visible
AknIconUtils::SetSize(defaultBitmap, TSize(iHdmiWidth,iHdmiHeight),EAspectRatioPreserved);
GLX_LOG_INFO2("CShwSlideshowView::SetImageToHDMIL - CGlxHdmi - Default Size width=%d, height=%d",
defaultBitmap->SizeInPixels().iWidth, defaultBitmap->SizeInPixels().iHeight);
if(nexterror == KErrNone)
{
iHdmiController->SetImageL(item.Uri(), nextItem.Uri(),
defaultBitmap);
}
else
{
iHdmiController->SetImageL(item.Uri(), KNullDesC , defaultBitmap);
}
CleanupStack::PopAndDestroy(defaultBitmap);
}
}
}
else
{
GLX_LOG_INFO("CShwSlideshowView::SetImageToHDMIL - Unsupported Item");
//Set the external display to cloning mode if
//the current item is something we wont support (e.g. video, corrupted item)
iHdmiController->ShiftToCloningMode();
}
}
// ---------------------------------------------------------------------------
//
// 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);
}
// ---------------------------------------------------------------------------
//
// HandleMMCInsertionL
// ---------------------------------------------------------------------------
//
void CShwSlideshowView::HandleMMCInsertionL()
{
TRACER("CShwSlideshowView::HandleMMCInsertionL()");
iMMCState = ETrue;
iPrevNotInBackground = iIsForegrnd;
if(iIsForegrnd)
{
ProcessCommandL(EAknSoftkeyClose);
}
}
// ---------------------------------------------------------------------------
//
// HandleMMCRemovalL
// ---------------------------------------------------------------------------
//
void CShwSlideshowView::HandleMMCRemovalL()
{
TRACER("CShwSlideshowView::HandleMMCRemovalL()");
ProcessCommandL(EAknSoftkeyExit);
}
// ---------------------------------------------------------------------------
//
// HandleTvStatusChangedL
// ---------------------------------------------------------------------------
//
void CShwSlideshowView::HandleTvStatusChangedL(TTvChangeType aChangeType )
{
TRACER("CShwSlideshowView::HandleTvStatusChangedL");
// This is a common function for both HDMI ,TV-out and Headset disconnected.
// (see CGlxTv::HandleTvConnectionStatusChangedL)
if (aChangeType == EDisconnected)
{
GLX_LOG_INFO("CShwSlideshowView::HandleTvStatusChangedL- Acessory Not Connected");
//Issue pause command if not already paused
if (!iPauseHandler->IsSlideShowEngineStatePaused())
{
ProcessCommandL(EShwSlideshowCmdPause);
}
}
}
// ---------------------------------------------------------------------------
// GetNextIndex
// ---------------------------------------------------------------------------
//
TInt CShwSlideshowView::GetNextIndex()
{
TRACER("CShwSlideshowView::GetNextIndex");
TInt count = iFilteredList->Count();
TInt focusIndex = iFilteredList->FocusIndex();
TInt nextIndex = focusIndex + 1;
if (nextIndex > count - 1)
{
nextIndex = nextIndex - count;
}
GLX_LOG_INFO1("CShwSlideshowView::GetNextIndex-nextIndex:%d",nextIndex);
return nextIndex;
}
//---------------------------------------------------------------------------
// From MGlxHDMIDecoderObserver
// Handle notification of HDMI Image Decoder.
//---------------------------------------------------------------------------
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();
}
}