/*
* Copyright (c) 2008-2009 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: Navigational state of the app
*
*/
#include "glxnavigationalstate.h"
#include <glxassert.h>
#include <glxsingletonstore.h>
#include <mpxcollectionobserver.h>
#include <mpxcollectionmessage.h>
#include <mpxcollectionpath.h>
#include <mpxcollectionutility.h>
#include <mpxmessagegeneraldefs.h>
#include <mpxviewutility.h> // MMPXViewUtility
#include "mglxnavigationalstateobserver.h"
#include <eikappui.h>
#include <eikenv.h>
#include <glxtracer.h>
#include <glxlog.h>
/**
* CGlxNavigationalStateImp
*
* Implementation of navigational state
* Note: function entry-exit logging is in CGlxNavigationalState,
* not in CGlxNavigationalStateImp.
*
* @author Aki Vanhatalo
*/
class CGlxNavigationalStateImp : public CBase, public MMPXCollectionObserver
{
public:
/**
* Second-phase constructor
* inlined since used only once from CGlxNavigationalState
*/
inline void ConstructL()
{
iCollectionUtility = MMPXCollectionUtility::NewL( this );
iViewUtility = MMPXViewUtility::UtilityL();
iViewingMode = NGlxNavigationalState::EBrowse;
}
/** Destructor */
~CGlxNavigationalStateImp()
{
GLX_LOG_ENTRY_EXIT( "CGlxNavigationalStateImp::~CGlxNavigationalStateImp");
if ( iCollectionUtility )
{
iCollectionUtility->Close();
}
if ( iViewUtility )
{
iViewUtility->Close();
}
// Log a warning if observers remaining; they should have been removed by the client
__ASSERT_DEBUG( !iObservers.Count(),
GLX_LOG_WARNING1( "CGlxNavigationalStateImp - %d observers not removed", iObservers.Count() ) );
iObservers.Close();
}
/**
* Add an observer
* inlined since used only once from CGlxNavigationalState
* @param aObserver Observer of changes to state
*/
inline void AddObserverL( MGlxNavigationalStateObserver& aObserver )
{
GLX_LOG_INFO1("CGlxNavigationalStateImp::AddObserverL %x", &aObserver);
__ASSERT_DEBUG( KErrNotFound == iObservers.Find( &aObserver ),
GLX_LOG_WARNING( "CGlxNavigationalStateImp - Observer already added" ) );
// Add the observer, unless already added
if ( KErrNotFound == iObservers.Find( &aObserver ) )
{
iObservers.AppendL( &aObserver );
}
}
/**
* Remove an observer
* inlined since used only once from CGlxNavigationalState
* @param aObserver Observer to remove
*/
inline void RemoveObserver( MGlxNavigationalStateObserver& aObserver )
{
GLX_LOG_INFO1("CGlxNavigationalStateImp::RemoveObserver %x", &aObserver);
// Remove the observer if exists
TInt index = iObservers.Find( &aObserver );
if ( KErrNotFound != index )
{
iObservers.Remove( index );
}
__ASSERT_DEBUG( KErrNotFound != index,
GLX_LOG_WARNING( "CGlxNavigationalStateImp - No such observer to remove" ) );
}
/**
* @return the current navigational state. Caller gets ownership.
*/
CMPXCollectionPath* StateLC() const
{
GLX_LOG_ENTRY_EXIT("CGlxNavigationalStateImp::StateLC");
// state is stored in the collection utility as a collection path
CMPXCollectionPath* state = Collection().PathL();
CleanupStack::PushL( state );
// go up one level in hierarchy, since the path contains also the
// currently open level, not only the nodes to the level
state->Back();
return state;
}
/**
* Navigate back in the UI hierarchy
* Does nothing, if currently at root.
*/
inline void NavigateToParentL()
{
if ( ViewingMode()== NGlxNavigationalState::EView )
{
iViewingMode = NGlxNavigationalState::EBrowse;
//Collection().BackL(); // added by gopakumar
NotifyObserversOfStateChange();
}
else
{
Collection().BackL();
}
}
/**
* Navigate forward to provided item
* @param aItemToOpen Id of item to navigate to
*/
void NavigateToChildL( const TGlxMediaId& aItemIdToOpen )
{
// there is no way to open MPX collection utility's current state with
// and id of a child item, so create a full path object and add the
// requested item's id as the new level
iViewingMode = NGlxNavigationalState::EBrowse;
CMPXCollectionPath* state = StateLC();
state->AppendL( aItemIdToOpen.Value() );
NavigateToL( *state );
CleanupStack::PopAndDestroy( state );
}
/**
* Navigate to provided position in hierarchy
* @param aNewState Path object which describes the new position in hierarchy
*/
inline void NavigateToL( const CMPXCollectionPath& aNewState )
{
// (it does not matter that the root level is opened without
// gallery plugin filter (EGlxCollectionPluginGallery), as long as
// the root level is *rendered* with something that uses the filter,
// such as a media list)
if(!iIsNavigating)
{
iViewingMode = NGlxNavigationalState::EBrowse;
Collection().OpenL( aNewState );
iIsNavigating = ETrue;
}
}
// commented off by gopakumar , as this is no longer needed .
/**
* Set the ID of the view that will be activated if there are no other
* view's in the view history
*/
/*inline void SetFirstViewId( TVwsViewId aViewId )
{
// Save the view Id
iViewId = aViewId;
}*/
/**
* Activate previous view
*/
inline void ActivatePreviousViewL()
{
iViewingMode = NGlxNavigationalState::EBrowse;
//go back one view
if ( iViewUtility->ViewHistoryDepth() > 1 )
{
iViewUtility->ActivatePreviousViewL();
}
}
// From MMPXCollectionObserver
void HandleCollectionMessageL( const CMPXMessage& aMessage )
{
TRACER( "CGlxNavigationalStateImp::HandleCollectionMessageL" );
if ( IsPathChangedMessage( aMessage ) )
{
NotifyObserversOfStateChange();
iIsNavigating = EFalse;
}
}
// From MMPXCollectionObserver
void HandleOpenL( const CMPXMedia& /*aEntries*/, TInt /*aIndex*/,
TBool /*aComplete*/, TInt /*aError*/ )
{
// do nothing
}
// From MMPXCollectionObserver
void HandleOpenL( const CMPXCollectionPlaylist& /*aPlaylist*/, TInt /*aError*/ )
{
// do nothing
}
// From MMPXCollectionObserver
void HandleCollectionMediaL( const CMPXMedia& /*aMedia*/, TInt /*aError*/ )
{
// do nothing
}
void SetToViewMode()
{
iViewingMode = NGlxNavigationalState::EView;
// inform the observers( only appui!! ) that the mode is view
NotifyObserversOfStateChange();
}
NGlxNavigationalState::TViewingMode ViewingMode()
{
return iViewingMode;
}
private:
/** Notify observers of state change */
inline void NotifyObserversOfStateChange()
{
GLX_LOG_ENTRY_EXIT( "CGlxNavigationalStateImp::NotifyObserversOfStateChange" );
// iObservers::Count() used in loop: ok, since unlikely to have many observers
for ( TInt i = 0; i < iObservers.Count(); i++ )
{
iObservers[ i ]->HandleNavigationalStateChangedL();
}
}
/** @return MPX collection */
inline MMPXCollection& Collection() const
{
return iCollectionUtility->Collection();
}
/**
* @param aMessage message to test
* @return ETrue if the message is a "path changed" message
*/
inline TBool IsPathChangedMessage( const CMPXMessage& aMessage )
{
// message is a "path changed" message if message id is KMPXMessageGeneral
// and KMPXMessageGeneralEvent attribute is EPathChanged
return ( aMessage.IsSupported(KMPXMessageGeneralId )
&& KMPXMessageGeneral == aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralId )
&& aMessage.IsSupported( KMPXMessageGeneralEvent )
&& TMPXCollectionMessage::EPathChanged == aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralEvent ) );
}
private:
/// Collection utility that stores the path to represent current navigational
/// state
MMPXCollectionUtility* iCollectionUtility;
MMPXViewUtility* iViewUtility;
NGlxNavigationalState::TViewingMode iViewingMode;
// commented off by gopakumar as this is not used anymore
// TVwsViewId iViewId;
/// List of observers
RPointerArray< MGlxNavigationalStateObserver > iObservers;
TBool iIsNavigating; // If ETrue it means Navigating is already happening, so not allowed to navigate before current navigation Completes.
// If EFalse it means Navigation can happen
};
// -----------------------------------------------------------------------------
// InstanceL
// -----------------------------------------------------------------------------
//
EXPORT_C CGlxNavigationalState* CGlxNavigationalState::InstanceL()
{
GLX_LOG_INFO( "CGlxNavigationalState::InstanceL" );
return CGlxSingletonStore::InstanceL( &NewL );
}
// -----------------------------------------------------------------------------
// NewL
// -----------------------------------------------------------------------------
//
CGlxNavigationalState* CGlxNavigationalState::NewL()
{
GLX_LOG_INFO( "CGlxNavigationalState::NewL" );
CGlxNavigationalState* self = new ( ELeave ) CGlxNavigationalState;
CleanupStack::PushL( self );
// Construct implementation object
self->iImp = new ( ELeave ) CGlxNavigationalStateImp;
self->iImp->ConstructL();
CleanupStack::Pop( self );
return self;
}
// -----------------------------------------------------------------------------
// Destructor
// -----------------------------------------------------------------------------
//
CGlxNavigationalState::~CGlxNavigationalState()
{
delete iImp;
}
// -----------------------------------------------------------------------------
// Close a reference
// -----------------------------------------------------------------------------
//
EXPORT_C void CGlxNavigationalState::Close()
{
GLX_LOG_ENTRY_EXIT( "CGlxNavigationalState::Close");
// Decrease reference count, and delete if last one
CGlxSingletonStore::Close( this );
// Member variable access not safe after CGlxSingletonStore::Close()
}
// -----------------------------------------------------------------------------
// Close a reference
// -----------------------------------------------------------------------------
//
EXPORT_C void CGlxNavigationalState::AddObserverL(
MGlxNavigationalStateObserver& aObserver )
{
GLX_LOG_INFO1( "CGlxNavigationalState::AddObserverL %x", &aObserver );
iImp->AddObserverL( aObserver );
}
// -----------------------------------------------------------------------------
// Close a reference
// -----------------------------------------------------------------------------
//
EXPORT_C void CGlxNavigationalState::RemoveObserver(
MGlxNavigationalStateObserver& aObserver )
{
GLX_LOG_INFO1( "CGlxNavigationalState::RemoveObserver %x", &aObserver );
iImp->RemoveObserver( aObserver );
}
// -----------------------------------------------------------------------------
// Close a reference
// -----------------------------------------------------------------------------
//
EXPORT_C CMPXCollectionPath* CGlxNavigationalState::StateLC() const
{
GLX_LOG_ENTRY_EXIT( "CGlxNavigationalState::StateLC" );
return iImp->StateLC();
}
// -----------------------------------------------------------------------------
// Navigate to parent item
// -----------------------------------------------------------------------------
//
EXPORT_C void CGlxNavigationalState::NavigateToParentL()
{
GLX_LOG_ENTRY_EXIT( "CGlxNavigationalState::NavigateToParentL" );
iImp->NavigateToParentL();
}
// -----------------------------------------------------------------------------
// Navigate to a child item
// -----------------------------------------------------------------------------
//
EXPORT_C void CGlxNavigationalState::NavigateToChildL(
const TGlxMediaId& aItemIdToOpen )
{
// GLX_LOG_INFO1( "CGlxNavigationalState::NavigateToChildL %d", aItemIdToOpen.Value() );
iImp->NavigateToChildL( aItemIdToOpen );
}
// -----------------------------------------------------------------------------
// Navigate to a path
// -----------------------------------------------------------------------------
//
EXPORT_C void CGlxNavigationalState::NavigateToL( const CMPXCollectionPath& aState )
{
GLX_LOG_ENTRY_EXIT( "CGlxNavigationalState::NavigateToL");
iImp->NavigateToL( aState );
}
// -----------------------------------------------------------------------------
// Activate previous view
// -----------------------------------------------------------------------------
//
EXPORT_C void CGlxNavigationalState::ActivatePreviousViewL()
{
GLX_LOG_ENTRY_EXIT( "CGlxNavigationalState::ActivatePreviousViewL");
iImp->ActivatePreviousViewL();
}
EXPORT_C void CGlxNavigationalState::SetToViewMode()
{
iImp->SetToViewMode();
// inform the observers( only appui!! ) that the mode is view
}
EXPORT_C NGlxNavigationalState::TViewingMode CGlxNavigationalState::ViewingMode()
{
return iImp->ViewingMode();
}
EXPORT_C void CGlxNavigationalState::SetBackExitStatus(TBool aStatus)
{
iBackExitStatus = aStatus;
}
EXPORT_C TBool CGlxNavigationalState::BackExitStatus()
{
return iBackExitStatus;
}
// EOF