--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ncdengine/provider/server/src/ncdfavoritemanagerimpl.cpp Thu Dec 17 08:51:10 2009 +0200
@@ -0,0 +1,880 @@
+/*
+* Copyright (c) 2006 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: Contains CNcdFavoriteManager class
+*
+*/
+
+
+#include <s32mem.h>
+
+#include "ncdfavoritemanagerimpl.h"
+#include "ncdnodefunctionids.h"
+#include "catalogsbasemessage.h"
+#include "catalogsconstants.h"
+#include "catalogscontext.h"
+#include "ncdnodeidentifier.h"
+#include "ncdstorage.h"
+#include "ncdstoragemanagerimpl.h"
+#include "ncdstorageitem.h"
+#include "ncdproviderdefines.h"
+#include "ncddatabasestorage.h"
+#include "ncdnodemanager.h"
+#include "ncdnodecachecleanermanager.h"
+#include "ncdnodecachecleaner.h"
+#include "ncdnodedbmanager.h"
+#include "ncdnodedisclaimer.h"
+#include "ncdnodeimpl.h"
+#include "ncdnodemetadataimpl.h"
+#include "catalogsutils.h"
+#include "ncdgeneralmanager.h"
+
+#include "catalogsdebug.h"
+
+CNcdFavoriteManager* CNcdFavoriteManager::NewL(
+ CNcdGeneralManager& aGeneralManager )
+ {
+ CNcdFavoriteManager* self = NewLC( aGeneralManager );
+ CleanupStack::Pop( self );
+ return self;
+ }
+
+CNcdFavoriteManager* CNcdFavoriteManager::NewLC(
+ CNcdGeneralManager& aGeneralManager )
+ {
+ CNcdFavoriteManager* self =
+ new( ELeave ) CNcdFavoriteManager( aGeneralManager );
+ CleanupClosePushL( *self );
+ self->ConstructL();
+ return self;
+ }
+
+CNcdFavoriteManager::CNcdFavoriteManager(
+ CNcdGeneralManager& aGeneralManager )
+ : iGeneralManager( aGeneralManager ),
+ iNodeManager( aGeneralManager.NodeManager() ),
+ iStorageManager( aGeneralManager.StorageManager() )
+ {
+ }
+
+void CNcdFavoriteManager::ConstructL()
+ {
+ DLTRACEIN((""));
+ }
+
+CNcdFavoriteManager::~CNcdFavoriteManager()
+ {
+ iFavorites.ResetAndDestroy();
+ iTempFavorites.ResetAndDestroy();
+ }
+
+TInt CNcdFavoriteManager::ClientCount() const
+ {
+ return iFavorites.Count();
+ }
+
+TUid CNcdFavoriteManager::ClientL( TInt aClientIndex ) const
+ {
+ if ( aClientIndex < 0 || aClientIndex >= iFavorites.Count() )
+ {
+ User::Leave( KErrNotFound );
+ }
+ return iFavorites[ aClientIndex ]->ClientUid();
+ }
+
+const RPointerArray<CNcdNodeIdentifier>& CNcdFavoriteManager::FavoriteNodesL(
+ const TUid& aClientUid )
+ {
+ DLTRACEIN((""));
+
+ // Load client's favorites from DB, if they are not loaded.
+ DbLoadFavoritesL( aClientUid );
+
+ TInt index = FindClientFavorites( aClientUid );
+ DASSERT( index != KErrNotFound );
+ CNcdClientFavorites* clientFavorites = iFavorites[ index ];
+
+ return clientFavorites->Identifiers();
+ }
+
+
+TBool CNcdFavoriteManager::IsFavorite(
+ const CNcdNodeIdentifier& aNodeIdentifier ) const
+ {
+ DLTRACEIN((""));
+ const TUid& clientUid = aNodeIdentifier.ClientUid();
+
+ TInt index = FindClientFavorites( clientUid );
+ if ( index == KErrNotFound )
+ {
+ return EFalse;
+ }
+
+ CNcdClientFavorites* clientFavorites = iFavorites[ index ];
+ return clientFavorites->HasFavorite( aNodeIdentifier );
+ }
+
+
+void CNcdFavoriteManager::RemoveFavoritesL( const TUid& aClientUid )
+ {
+ DLTRACEIN((""));
+ TInt index = FindClientFavorites( aClientUid );
+ if ( index != KErrNotFound )
+ {
+ CNcdClientFavorites& clientFavorites = *iFavorites[ index ];
+ clientFavorites.RemoveFavorites();
+ DbSaveFavoritesL( clientFavorites );
+ }
+ }
+
+void CNcdFavoriteManager::ReceiveMessage(
+ MCatalogsBaseMessage* aMessage, TInt aFunctionNumber )
+ {
+ DLTRACEIN((""));
+
+ TInt trapError( KErrNone );
+
+ // Check which function is called by the proxy side object.
+ // Function number are located in ncdnodefunctinoids.h file.
+ switch( aFunctionNumber )
+ {
+ case NcdNodeFunctionIds::ENcdInternalize:
+ TRAP( trapError, InternalizeRequestL( *aMessage ) );
+ break;
+
+ case NcdNodeFunctionIds::ENcdFavoriteManagerAddFavorite:
+ TRAP( trapError, AddFavoriteRequestL( *aMessage ) );
+ break;
+
+ case NcdNodeFunctionIds::ENcdFavoriteManagerRemoveFavorite:
+ TRAP( trapError, RemoveFavoriteRequestL( *aMessage ) );
+ break;
+
+ case NcdNodeFunctionIds::ENcdFavoriteManagerSetDisclaimer:
+ TRAP( trapError, SetDisclaimerRequestL( *aMessage ) );
+ break;
+
+ case NcdNodeFunctionIds::ENcdFavoriteManagerDisclaimerHandle:
+ TRAP( trapError, DisclaimerHandleRequestL( *aMessage ) );
+ break;
+
+ case NcdNodeFunctionIds::ENcdRelease:
+ // The proxy does not want to use this object anymore.
+ // So, release the handle from the session.
+ ReleaseRequest( *aMessage );
+ break;
+
+ default:
+ DASSERT( EFalse );
+ break;
+ }
+
+ if ( trapError != KErrNone )
+ {
+ // Because something went wrong, the complete has not been
+ // yet called for the message.
+ // So, inform the client about the error if the
+ // message is still available.
+ aMessage->CompleteAndRelease( trapError );
+ }
+ }
+
+
+void CNcdFavoriteManager::CounterPartLost( const MCatalogsSession& /*aSession*/ )
+ {
+ DLTRACEIN((""));
+ }
+
+
+void CNcdFavoriteManager::AddFavoriteRequestL( MCatalogsBaseMessage& aMessage )
+ {
+ DLTRACEIN((""));
+
+ RCatalogsMessageReader reader;
+ reader.OpenLC( aMessage );
+
+ CNcdNodeIdentifier* nodeId = CNcdNodeIdentifier::NewLC( reader() );
+ TBool removeOnDisconnect = reader().ReadInt8L();
+
+ if ( removeOnDisconnect )
+ {
+ // Add the identifier with session information. Session
+ // information is needed when the favorite must be removed, that is, when
+ // the session is released.
+ AddTemporaryFavoriteL( nodeId, aMessage.Session() );
+ }
+ else
+ {
+ AddFavoriteL( nodeId );
+ }
+
+ CleanupStack::Pop( nodeId );
+ CleanupStack::PopAndDestroy( &reader );
+
+ aMessage.CompleteAndRelease( KErrNone );
+ }
+
+
+void CNcdFavoriteManager::RemoveFavoriteRequestL( MCatalogsBaseMessage& aMessage )
+ {
+ DLTRACEIN((""));
+
+ RCatalogsMessageReader reader;
+ reader.OpenLC( aMessage );
+
+ CNcdNodeIdentifier* nodeId = CNcdNodeIdentifier::NewLC( reader() );
+ RemoveFavoriteL( nodeId );
+
+ CleanupStack::Pop( nodeId );
+ CleanupStack::PopAndDestroy( &reader );
+
+ aMessage.CompleteAndRelease( KErrNone );
+ }
+
+
+void CNcdFavoriteManager::SetDisclaimerRequestL( MCatalogsBaseMessage& aMessage )
+ {
+ DLTRACEIN((""));
+
+ RCatalogsMessageReader reader;
+ reader.OpenLC( aMessage );
+
+ // Get the favorite node identifier.
+ CNcdNodeIdentifier* favoriteIdentifier = CNcdNodeIdentifier::NewLC( reader() );
+ DLNODEID(( *favoriteIdentifier ));
+ TInt clientIndex = FindClientFavorites( favoriteIdentifier->ClientUid() );
+ DASSERT( clientIndex != KErrNotFound );
+ CNcdClientFavorites* favorites = iFavorites[ clientIndex ];
+
+ // Read whether the stream contains the disclaimer owner.
+ TBool isDisclaimer = reader().ReadInt32L();
+
+ if ( isDisclaimer )
+ {
+ DLINFO(("Setting disclaimer for favorite node"));
+ CNcdNodeIdentifier* disclaimerOwner = CNcdNodeIdentifier::NewLC( reader() );
+ CNcdNode& node = iNodeManager.NodeL( *disclaimerOwner );
+ CNcdNodeMetaData& metadata = node.NodeMetaDataL();
+ const CNcdNodeDisclaimer* disclaimer = NULL;
+
+ // ownership is not transferred
+ // DisclaimerL leaves only with KErrNotFound
+ TRAP_IGNORE( disclaimer = &metadata.DisclaimerL() );
+
+ if ( !disclaimer )
+ {
+ DLINFO(("Getting disclaimer from favorites"));
+ // ownership is not transferred
+ disclaimer = favorites->Disclaimer( *disclaimerOwner );
+ }
+
+ if ( disclaimer )
+ {
+ favorites->SetDisclaimerL( *favoriteIdentifier, *disclaimer );
+ }
+ else
+ {
+ DLERROR(("No disclaimer found, leaving with KErrNotFound"));
+ User::Leave( KErrNotFound );
+ }
+
+ CleanupStack::PopAndDestroy( disclaimerOwner );
+ }
+ else
+ {
+ DLINFO(("Removing disclaimer from favorite node"));
+ favorites->RemoveDisclaimer( *favoriteIdentifier );
+ }
+
+ CleanupStack::PopAndDestroy( favoriteIdentifier );
+ CleanupStack::PopAndDestroy( &reader );
+
+ // Update the state to db.
+ DbSaveFavoritesL( *favorites );
+
+ aMessage.CompleteAndRelease( KErrNone );
+ }
+
+
+void CNcdFavoriteManager::DisclaimerHandleRequestL(
+ MCatalogsBaseMessage& aMessage )
+ {
+ DLTRACEIN((""));
+
+ RCatalogsMessageReader reader;
+ reader.OpenLC( aMessage );
+
+ // Get the favorite node identifier.
+ CNcdNodeIdentifier* favoriteIdentifier = CNcdNodeIdentifier::NewL( reader() );
+
+ CleanupStack::PopAndDestroy( &reader );
+
+ TInt clientIndex = FindClientFavorites( favoriteIdentifier->ClientUid() );
+ DASSERT( clientIndex != KErrNotFound );
+ CNcdClientFavorites* favorites = iFavorites[ clientIndex ];
+ CNcdNodeDisclaimer* disclaimer = favorites->Disclaimer( *favoriteIdentifier );
+
+ delete favoriteIdentifier;
+ favoriteIdentifier = NULL;
+
+ if ( disclaimer == NULL )
+ {
+ // Disclaimer was not found for the node.
+ User::Leave( KErrNotFound );
+ }
+
+ // Get the session that will contain the handle of the disclaimer.
+ MCatalogsSession& requestSession( aMessage.Session() );
+
+ // Add the icon to the session and get the handle.
+ // If the node already existed in the session we will still
+ // get a new handle to the same object.
+ TInt32 handle( requestSession.AddObjectL( disclaimer ) );
+
+ DLINFO(("Disclaimer handle: %d", handle ));
+
+ // Send the information to the client side
+ // If this leaves, ReceiveMessage will complete the message.
+ aMessage.CompleteAndReleaseL( handle, KErrNone );
+ }
+
+
+void CNcdFavoriteManager::ReleaseRequest(
+ MCatalogsBaseMessage& aMessage )
+ {
+ DLTRACEIN((""));
+
+ // Decrease the reference count for this object.
+ // When the reference count reaches zero, this object will be destroyed
+ // and removed from the session.
+ MCatalogsSession& requestSession( aMessage.Session() );
+ TInt handle( aMessage.Handle() );
+
+ // Remove the temporary favorites of the session.
+ TRAPD( err, RemoveTemporaryFavoritesL( requestSession ) );
+
+ // Send complete information back to proxy.
+ aMessage.CompleteAndRelease( err );
+
+ // Remove this object from the session.
+ requestSession.RemoveObject( handle );
+
+ DLTRACEOUT((""));
+ }
+
+
+void CNcdFavoriteManager::AddFavoriteL( CNcdNodeIdentifier* aNodeIdentifier )
+ {
+ DLTRACEIN((""));
+ DASSERT( aNodeIdentifier != NULL );
+
+ TInt index = FindClientFavorites( aNodeIdentifier->ClientUid() );
+ CNcdClientFavorites* favorites = iFavorites[ index ];
+
+ // Add the node to node cache cleaner's block list, so it will never be removed
+ // from db.
+ iNodeManager.NodeCacheCleanerManager().CacheCleanerL(
+ aNodeIdentifier->ClientUid() ).AddDoNotRemoveIdentifierL(
+ *aNodeIdentifier, ETrue );
+
+ favorites->AddFavoriteL( aNodeIdentifier );
+ DbSaveFavoritesL( *favorites );
+ }
+
+
+void CNcdFavoriteManager::AddTemporaryFavoriteL(
+ CNcdNodeIdentifier* aNodeIdentifier,
+ MCatalogsSession& aSession )
+ {
+ DLTRACEIN((""));
+ DASSERT( aNodeIdentifier != NULL );
+
+ // The node is favorite already, do nothing.
+ if ( IsFavorite( *aNodeIdentifier ) )
+ {
+ delete aNodeIdentifier;
+ return;
+ }
+
+ CNcdNodeIdentifier* copy = CNcdNodeIdentifier::NewLC( *aNodeIdentifier );
+
+ // Map the identifier and the session so that the node can be removed when the
+ // session is released.
+ CNcdTemporaryFavorites& tempFavorites = TemporaryFavoritesL( aSession );
+ tempFavorites.iFavoriteIdentifiers.AppendL( copy );
+ CleanupStack::Pop( copy );
+
+ // Add the favorite normally.
+ AddFavoriteL( aNodeIdentifier );
+ }
+
+
+void CNcdFavoriteManager::RemoveFavoriteL( CNcdNodeIdentifier* aNodeIdentifier )
+ {
+ DLTRACEIN((""));
+ DASSERT( aNodeIdentifier != NULL );
+
+ TInt index = FindClientFavorites( aNodeIdentifier->ClientUid() );
+ DASSERT( index != KErrNotFound );
+ CNcdClientFavorites* favorites = iFavorites[ index ];
+
+ // Remove the node from node db mananager's block list, so it can be removed from
+ // db.
+ iNodeManager.NodeCacheCleanerManager().CacheCleanerL(
+ aNodeIdentifier->ClientUid() ).RemoveDoNotRemoveIdentifierL(
+ *aNodeIdentifier, ETrue );
+
+ favorites->RemoveFavorite( *aNodeIdentifier );
+ DbSaveFavoritesL( *favorites );
+ delete aNodeIdentifier;
+ }
+
+
+void CNcdFavoriteManager::RemoveTemporaryFavoritesL( MCatalogsSession& aSession )
+ {
+ DLTRACEIN((""));
+ if ( HasTemporaryFavorites( aSession ) )
+ {
+ CNcdTemporaryFavorites& tempFavorites = TemporaryFavoritesL( aSession );
+ for ( TInt i = tempFavorites.iFavoriteIdentifiers.Count() - 1; i >= 0; i-- )
+ {
+ // Remove the favorite, deletes also the given node identifier object.
+ RemoveFavoriteL( tempFavorites.iFavoriteIdentifiers[ i ] );
+ tempFavorites.iFavoriteIdentifiers.Remove( i );
+ }
+ }
+ }
+
+
+void CNcdFavoriteManager::InternalizeRequestL( MCatalogsBaseMessage& aMessage )
+ {
+ DLTRACEIN((""));
+
+ // We need session info in the functions for example to
+ // check the client id (there can be several clients).
+ MCatalogsSession& session = aMessage.Session();
+ TUid clientUid = session.Context().FamilyId();
+
+ // If the client favorites are not loaded from Db, do it now.
+ DbLoadFavoritesL( clientUid );
+
+ RCatalogsBufferWriter writer;
+ writer.OpenLC();
+
+ ExternalizeIdentifiersL( writer(), clientUid );
+
+ // If this leaves, ReceiveMessage will complete the message.
+ // NOTE: that here we expect that the buffer contains at least
+ // some data. So, make sure that ExternalizeIdentifiersL inserts
+ // something to the buffer.
+ aMessage.CompleteAndReleaseL( writer.PtrL(), KErrNone );
+
+ CleanupStack::PopAndDestroy( &writer );
+ }
+
+void CNcdFavoriteManager::ExternalizeIdentifiersL(
+ RWriteStream& aStream, const TUid& aClientUid )
+ {
+ DLTRACEIN((""));
+
+ TInt index = FindClientFavorites( aClientUid );
+ DASSERT( index != KErrNotFound );
+
+ CNcdClientFavorites* favorites = iFavorites[ index ];
+ favorites->ExternalizeIdentifiersL( aStream );
+ }
+
+
+TInt CNcdFavoriteManager::FindClientFavorites( const TUid& aClientUid ) const
+ {
+ DLTRACEIN((""));
+ for ( TInt i = 0; i < iFavorites.Count(); i++ )
+ {
+ if ( iFavorites[ i ]->ClientUid() == aClientUid )
+ {
+ return i;
+ }
+ }
+
+ return KErrNotFound;
+ }
+
+
+CNcdFavoriteManager::CNcdTemporaryFavorites& CNcdFavoriteManager::TemporaryFavoritesL(
+ MCatalogsSession& aSession )
+ {
+ DLTRACEIN((""));
+
+ // Find the correct CNcdTemporaryFavorites object from the array.
+ for ( TInt i = 0; i < iTempFavorites.Count(); i++ )
+ {
+ if ( &iTempFavorites[ i ]->iSession == &aSession )
+ {
+ return *iTempFavorites[ i ];
+ }
+ }
+
+ // There was no existing CNcdTemporaryFavorites object, create one and return it.
+ CNcdTemporaryFavorites* temp = new( ELeave ) CNcdTemporaryFavorites( aSession );
+ CleanupStack::PushL( temp );
+ iTempFavorites.AppendL( temp );
+ CleanupStack::Pop( temp );
+ return *temp;
+ }
+
+
+TBool CNcdFavoriteManager::HasTemporaryFavorites( MCatalogsSession& aSession ) const
+ {
+ DLTRACEIN((""));
+ for ( TInt i = 0; i < iTempFavorites.Count(); i++ )
+ {
+ if ( &iTempFavorites[ i ]->iSession == &aSession )
+ {
+ return iTempFavorites[ i ]->iFavoriteIdentifiers.Count() > 0;
+ }
+ }
+ return EFalse;
+ }
+
+
+void CNcdFavoriteManager::DbLoadFavoritesL( const TUid& aClientUid )
+ {
+ DLTRACEIN((""));
+
+ if ( FindClientFavorites( aClientUid ) != KErrNotFound )
+ {
+ // Client favorites already loaded, return
+ return;
+ }
+
+ MNcdStorage& providerStorage = iStorageManager.ProviderStorageL(
+ iGeneralManager.FamilyName() );
+ MNcdDatabaseStorage& database =
+ providerStorage.DatabaseStorageL( NcdProviderDefines::KDefaultDatabaseUid );
+
+ if( !database.ItemExistsInStorageL( aClientUid.Name(),
+ NcdProviderDefines::ENcdFavoriteManager ) )
+ {
+ // Create empty list of favorites
+ CNcdClientFavorites* list = CNcdClientFavorites::NewLC( aClientUid );
+ iFavorites.AppendL( list );
+ CleanupStack::Pop( list );
+ }
+ else
+ {
+ // Get the storage item from which the data is loaded
+ // Note: database has the ownership of the item
+ MNcdStorageItem* item = database.StorageItemL(
+ aClientUid.Name(), NcdProviderDefines::ENcdFavoriteManager );
+
+ // Get data from database by using CNcdClientFavorites as the target so that
+ // internalize will be called for it
+ CNcdClientFavorites* data = CNcdClientFavorites::NewLC( aClientUid );
+ item->SetDataItem( data );
+
+ // Read data -> calls CNcdClientFavorites::InternalizeL
+ item->ReadDataL();
+
+ iFavorites.AppendL( data );
+ CleanupStack::Pop( data );
+
+ // Add the favorites to node cache cleaner's list of nodes that must never be
+ // removed from db.
+ iNodeManager.NodeCacheCleanerManager().CacheCleanerL(
+ aClientUid ).AddDoNotRemoveIdentifiersL( data->Identifiers(), ETrue );
+ }
+ }
+
+
+void CNcdFavoriteManager::DbSaveFavoritesL( CNcdClientFavorites& aFavorites )
+ {
+ DLTRACEIN((""));
+
+ MNcdStorage& providerStorage = iStorageManager.ProviderStorageL(
+ iGeneralManager.FamilyName() );
+ MNcdDatabaseStorage& database =
+ providerStorage.DatabaseStorageL( NcdProviderDefines::KDefaultDatabaseUid );
+
+ // Get the storage item to which the access point manager is stored
+ // Note: database has the ownership of the item
+ MNcdStorageItem* item = database.StorageItemL(
+ aFavorites.ClientUid().Name(), NcdProviderDefines::ENcdFavoriteManager);
+ item->SetDataItem( &aFavorites );
+ item->OpenL();
+
+ // Calls ExternalizeL for this
+ item->WriteDataL();
+ item->SaveL();
+ }
+
+
+CNcdFavoriteManager::CNcdClientFavorites* CNcdFavoriteManager::CNcdClientFavorites::NewLC(
+ const TUid& aClientUid )
+ {
+ DLTRACEIN((""));
+ CNcdClientFavorites* self = new( ELeave ) CNcdClientFavorites( aClientUid );
+ CleanupStack::PushL( self );
+ return self;
+ }
+
+
+CNcdFavoriteManager::CNcdClientFavorites::CNcdClientFavorites( const TUid& aClientUid )
+ : iClientUid( aClientUid )
+ {
+ }
+
+
+CNcdFavoriteManager::CNcdClientFavorites::~CNcdClientFavorites()
+ {
+ RemoveFavorites();
+ }
+
+TUid CNcdFavoriteManager::CNcdClientFavorites::ClientUid() const
+ {
+ return iClientUid;
+ }
+
+void CNcdFavoriteManager::CNcdClientFavorites::AddFavoriteL(
+ CNcdNodeIdentifier* aNodeIdentifier )
+ {
+ DLTRACEIN((""));
+ DASSERT( aNodeIdentifier != NULL );
+ DASSERT( iIdentifiers.Count() == iDisclaimers.Count() );
+
+ iIdentifiers.ReserveL( iIdentifiers.Count() + 1 );
+ iDisclaimers.ReserveL( iDisclaimers.Count() + 1 );
+
+ TInt err1 = iIdentifiers.Append( aNodeIdentifier );
+
+ // Add NULL disclaimer for the node.
+ TInt err2 = iDisclaimers.Append( NULL );
+
+ DASSERT( err1 == KErrNone && err2 == KErrNone );
+ }
+
+void CNcdFavoriteManager::CNcdClientFavorites::RemoveFavorite(
+ const CNcdNodeIdentifier& aNodeIdentifier )
+ {
+ TInt count = iIdentifiers.Count();
+ DASSERT( iDisclaimers.Count() == count );
+
+ for ( TInt i = 0; i < count; i++ )
+ {
+ if ( iIdentifiers[ i ]->Equals( aNodeIdentifier ) )
+ {
+ delete iIdentifiers[ i ];
+ iIdentifiers.Remove( i );
+ if ( iDisclaimers[ i ] )
+ {
+ iDisclaimers[ i ]->Close();
+ }
+ iDisclaimers.Remove( i );
+ break;
+ }
+ }
+ }
+
+
+void CNcdFavoriteManager::CNcdClientFavorites::RemoveFavorites()
+ {
+ CloseDisclaimers();
+ iIdentifiers.ResetAndDestroy();
+ }
+
+
+void CNcdFavoriteManager::CNcdClientFavorites::SetDisclaimerL(
+ const CNcdNodeIdentifier& aNodeIdentifier,
+ const CNcdNodeDisclaimer& aDisclaimer )
+ {
+ DLTRACEIN((""));
+ DLNODEID( aNodeIdentifier );
+ DASSERT( iIdentifiers.Count() == iDisclaimers.Count() );
+ TInt count = iIdentifiers.Count();
+
+ for ( TInt i = 0; i < count; i++ )
+ {
+ CNcdNodeIdentifier* identifier = iIdentifiers[ i ];
+ if ( identifier->Equals( aNodeIdentifier ) )
+ {
+ // Correct index found, copy the disclaimer.
+ CNcdNodeDisclaimer* copy = CNcdNodeDisclaimer::NewL( aDisclaimer );
+ if ( iDisclaimers[ i ] )
+ {
+ iDisclaimers[ i ]->Close();
+ }
+ iDisclaimers[ i ] = copy;
+ break;
+ }
+ }
+ }
+
+
+void CNcdFavoriteManager::CNcdClientFavorites::RemoveDisclaimer(
+ const CNcdNodeIdentifier& aNodeIdentifier )
+ {
+ DASSERT( iIdentifiers.Count() == iDisclaimers.Count() );
+ TInt count = iIdentifiers.Count();
+
+ for ( TInt i = 0; i < count; i++ )
+ {
+ if ( iIdentifiers[ i ]->Equals( aNodeIdentifier ) )
+ {
+ // Correct index found, delete the disclaimer.
+ if ( iDisclaimers[ i ] )
+ {
+ iDisclaimers[ i ]->Close();
+ }
+ iDisclaimers[ i ] = NULL;
+ break;
+ }
+ }
+ }
+
+
+CNcdNodeDisclaimer* CNcdFavoriteManager::CNcdClientFavorites::Disclaimer(
+ const CNcdNodeIdentifier& aNodeIdentifier ) const
+ {
+ DASSERT( iIdentifiers.Count() == iDisclaimers.Count() );
+ TInt count = iIdentifiers.Count();
+ for ( TInt i = 0; i < count; i++ )
+ {
+ if ( iIdentifiers[ i ]->Equals( aNodeIdentifier ) )
+ {
+ return iDisclaimers[ i ];
+ }
+ }
+
+ return NULL;
+ }
+
+
+TBool CNcdFavoriteManager::CNcdClientFavorites::HasFavorite(
+ const CNcdNodeIdentifier& aNodeIdentifier ) const
+ {
+ TInt count = iIdentifiers.Count();
+ for ( TInt i = 0; i < count; i++ )
+ {
+ if ( iIdentifiers[ i ]->Equals( aNodeIdentifier ) )
+ {
+ return ETrue;
+ }
+ }
+ return EFalse;
+ }
+
+
+const RPointerArray<CNcdNodeIdentifier>& CNcdFavoriteManager::CNcdClientFavorites::Identifiers() const
+ {
+ return iIdentifiers;
+ }
+
+
+void CNcdFavoriteManager::CNcdClientFavorites::ExternalizeIdentifiersL(
+ RWriteStream& aStream ) const
+ {
+ DLTRACEIN((""));
+
+ TInt count = iIdentifiers.Count();
+ aStream.WriteInt32L( count );
+ for ( TInt i = 0; i < count; i++ )
+ {
+ iIdentifiers[ i ]->ExternalizeL( aStream );
+ }
+ }
+
+
+void CNcdFavoriteManager::CNcdClientFavorites::ExternalizeL( RWriteStream& aStream )
+ {
+ DLTRACEIN((""));
+ DASSERT( iIdentifiers.Count() == iDisclaimers.Count() );
+
+ TInt count = iIdentifiers.Count();
+ aStream.WriteInt32L( count );
+ for ( TInt i = 0; i < count; i++ )
+ {
+ iIdentifiers[ i ]->ExternalizeL( aStream );
+ if ( iDisclaimers[ i ] )
+ {
+ aStream.WriteInt8L( ETrue );
+ iDisclaimers[ i ]->ExternalizeL( aStream );
+ }
+ else
+ {
+ aStream.WriteInt8L( EFalse );
+ }
+ }
+ }
+
+void CNcdFavoriteManager::CNcdClientFavorites::InternalizeL( RReadStream& aStream )
+ {
+ DLTRACEIN((""));
+ iIdentifiers.ResetAndDestroy();
+
+ // Close all the disclaimer objects.
+ CloseDisclaimers();
+
+ // Reserve memory for the arrays.
+ TInt count = aStream.ReadInt32L();
+
+ iIdentifiers.ReserveL( count );
+ iDisclaimers.ReserveL( count );
+
+ // Read the stream.
+ for ( TInt i = 0; i < count; i++ )
+ {
+ CNcdNodeIdentifier* identifier = CNcdNodeIdentifier::NewLC( aStream );
+ CNcdNodeDisclaimer* disclaimer( NULL );
+ TBool isDisclaimer = aStream.ReadInt8L();
+ if ( isDisclaimer )
+ {
+ disclaimer = CNcdNodeDisclaimer::NewLC();
+ disclaimer->InternalizeL( aStream );
+ CleanupStack::Pop( disclaimer );
+ }
+
+ CleanupStack::Pop( identifier);
+
+ TInt err1 = iIdentifiers.Append( identifier );
+ TInt err2 = iDisclaimers.Append( disclaimer );
+
+ // Memory was allocated earlier, so error should never occur.
+ DASSERT( err1 == KErrNone && err2 == KErrNone );
+ }
+ }
+
+void CNcdFavoriteManager::CNcdClientFavorites::CloseDisclaimers()
+ {
+ TInt disclaimerCount = iDisclaimers.Count();
+ for ( TInt i = 0; i < disclaimerCount; i++ )
+ {
+ if ( iDisclaimers[ i ] )
+ {
+ iDisclaimers[ i ]->Close();
+ }
+ }
+ iDisclaimers.Reset();
+ }
+
+
+CNcdFavoriteManager::CNcdTemporaryFavorites::CNcdTemporaryFavorites(
+ MCatalogsSession& aSession )
+ : iSession( aSession )
+ {
+ }
+
+
+CNcdFavoriteManager::CNcdTemporaryFavorites::~CNcdTemporaryFavorites()
+ {
+ DLTRACEIN((""));
+ iFavoriteIdentifiers.ResetAndDestroy();
+ }