/*
* 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();
}