/*
* Copyright (c) 2003 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: This file contains the implementation of the CCbsDbImpTopicList class
* member functions.
*
* This class represents the topic list contained in the database.
*
*/
// INCLUDE FILES
#include <e32base.h>
#include <e32svr.h>
#include <f32file.h>
#include <shareddataclient.h> // RequestFreeDiskSpaceLC
#include <barsc.h> // Resource access
#include <barsread.h> // Resource access
#include <cbsserver.rsg>
#include "CbsServerPanic.h"
#include "CbsStreamHelper.h"
#include "CbsDbConstants.h"
#include "CbsUtils.h"
#include "CCbsDbImpTopicList.h"
#include "MCbsDbTopicListObserver.H"
#include "CCbsDbImpTopicMessages.h"
#include "CbsLogger.h"
#include <centralrepository.h> // for local variation
#include "cbsinternalcrkeys.h" // for local variation
#include "cbsvariant.hrh" // for local variation
// CONSTANTS
// Initial size for topic cache array
const TInt KDefaultTopicListSize = 10;
// Size of the topic stream, used in checking against FFS free space limit
const TInt KTopicStreamSize = 92;
// Size of the topic messages stream, FFS critical level check
const TInt KEmptyTopicMessagesStreamSize = 4;
// Size of topic list stream, FFS critical level check
const TInt KTopicListStreamSize = 85;
// Size of topic list stream (root), FFS critical level check
const TInt KTopicListRootStreamSize = 2;
// Time in microseconds to wait after a critical store exception
// before a recovery attempt is made.
const TInt KWaitAfterCriticalStoreException = 2000000;
// Used when unsaved message stream ids are deleted from topic messages
// stream
const TInt KTypicalNumberOfTopicMessages = 6;
// Minimum interval between compacting the stores in minutes
const TInt KMinimumCompactInterval = 30;
// Number of the index topic
const TInt KIndexTopicNumber = 0;
// Space for reading messages
const TInt KReadMessageSize = 92;
const TInt KTopicsGranularity = 1;
const TInt KTopicListsGranularity = 1;
const TInt KTopicIdsGranularity = 5;
// ================= MEMBER FUNCTIONS =======================
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::CCbsDbImpTopicList
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CCbsDbImpTopicList::CCbsDbImpTopicList(
RFs& aFs,
CCbsDbImp& aDatabase )
: iDatabase( aDatabase ),
iFs( aFs ),
iTopicCount( 0 ),
iInitializing( EFalse ),
iDeleteAllTopics( EFalse )
{
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::ConstructL(
const TDesC& aTopicsFile,
const TDesC& aUnsavedMessagesFile )
{
CBSLOGSTRING("CBSSERVER: >>> CCbsDbImpTopicList::ConstructL()");
// Create observer array
iObservers = new ( ELeave ) CArrayFixFlat< MCbsDbTopicListObserver* >(
KCbsDbObserverArraySize );
// Create topic array, additional memory size in new alloc, 1*192 B = 192 B
iTopics = new ( ELeave ) CArrayFixFlat< TCbsDbImpTopic >( KTopicsGranularity );
// Create the root item table, additional memory size in new alloc, 1*184 B = 184 B
iTopicLists = new ( ELeave ) CArrayFixFlat< TCbsDbImpTopicList >( KTopicListsGranularity );
// Create topic ID array, additional memory size in new alloc, 5*4 B = 20 B
iTopicIds = new ( ELeave ) CArrayFixFlat< TStreamId >( KTopicIdsGranularity );
// Initialize iPreviousCompact to now
iPreviousCompact.UniversalTime();
// Copy datafile names from parameters
iTopicsFilename = aTopicsFile.AllocL();
iUnsavedMessagesFilename = aUnsavedMessagesFile.AllocL();
// Fetch local variation bits from CenRep
CRepository* repository = CRepository::NewL( KCRUidCbsVariation );
TInt err = repository->Get( KCbsVariationFlags, iLVBits );
CBSLOGSTRING2("CBSSERVER: CCbsRecEtel::ConstructL(): CenRep error: %d", err );
if ( err )
{
iLVBits = 0;
}
delete repository;
// If aLoadFactorySettings, then the files are recreated and initialized.
// If not, then the nonexisting files are created, files opened and
// data internalized.
TBool unsavedMsgFileExists( CbsUtils::ExistsL( iFs, *iUnsavedMessagesFilename ) );
TBool loadFactorySettings( !CbsUtils::ExistsL( iFs, aTopicsFile ) );
TRAPD( error, OpenFilesL( loadFactorySettings, EFalse ) );
CBSLOGSTRING2("CBSSERVER: CCbsDbImpTopicList::ConstructL(): OpenFilesL() error: %d", error );
if ( error == KErrDiskFull )
{
// Delete the store and open is again
CBSLOGSTRING("CBSSERVER: CCbsDbImpTopicList::ConstructL(): About to delete iTopicStore..." );
delete iTopicStore;
iTopicStore = NULL;
CBSLOGSTRING("CBSSERVER: CCbsDbImpTopicList::ConstructL(): iTopicStore deletion finished." );
// Try to open the store again
TRAPD( error, iTopicStore = CFileStore::OpenL( iFs, *iTopicsFilename, EFileRead | EFileWrite ) );
CBSLOGSTRING2("CBSSERVER: CCbsDbImpTopicList::ConstructL(); iTopicStore OpenL() error: %d", error );
if ( error )
{
InitializeListL( ETrue );
}
}
else
{
if ( loadFactorySettings )
{
// Create a topic list for standard topics
if ( iTopicLists->Count() == 0 )
{
CreateStandardTopicListL();
}
}
// Only load the topics, if not already loaded when opening the files
if ( loadFactorySettings || unsavedMsgFileExists )
{
// Load the topics
LoadDefaultTopicStreamL();
}
// Compact the topic store
TopicStoreL()->CompactL();
TopicStoreL()->CommitL();
}
// Reset the unread message count to be sure that UI client gets the correct information,
// at this point count is always zero.
for ( TInt i( 0 ); i < iTopics->Count(); ++i )
{
iTopics->At( i ).iTopicData.iUnreadMessages = 0;
}
__TEST_INVARIANT;
CBSLOGSTRING("CBSSERVER: <<< CCbsDbImpTopicList::ConstructL()");
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CCbsDbImpTopicList* CCbsDbImpTopicList::NewL(
RFs& aFs,
const TDesC& aTopicsFile,
const TDesC& aUnsavedMessagesFile,
CCbsDbImp& aDatabase )
{
CCbsDbImpTopicList* self =
new ( ELeave ) CCbsDbImpTopicList( aFs, aDatabase );
CleanupStack::PushL( self );
self->ConstructL( aTopicsFile, aUnsavedMessagesFile );
CleanupStack::Pop();
return self;
}
// Destructor
CCbsDbImpTopicList::~CCbsDbImpTopicList()
{
CBSLOGSTRING("CBSSERVER: >>> CCbsDbImpTopicList::~CCbsDbImpTopicList()");
delete iTopics;
delete iTopicStore;
delete iTopicLists;
delete iTopicIds;
delete iUnsavedMessageStore;
delete iObservers;
delete iUnsavedMessagesFilename;
if ( iTopicsFilename )
{
delete iTopicsFilename;
}
CBSLOGSTRING("CBSSERVER: <<< CCbsDbImpTopicList::~CCbsDbImpTopicList()");
}
#ifndef __SECURE_BACKUP__
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::ChangeFileLockL
// Closes or reopens the settings file if requested by a backup.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::ChangeFileLockL(
const TDesC& aFileName,
TFileLockFlags aFlags )
{
CBSLOGSTRING2("CBSSERVER: >>> CCbsDbImpTopicList::ChangeFileLockL() (1): flag: %d", aFlags );
if ( aFlags == ETakeLock && iTopicStore == NULL )
{
CBSLOGSTRING("CBSSERVER: CCbsDbImpTopicList::ChangeFileLockL() (1): Try to open store...");
// Try to open the store.
iTopicStore = CPermanentFileStore::OpenL( iFs,
aFileName, EFileRead | EFileWrite );
CBSLOGSTRING("CBSSERVER: CCbsDbImpTopicList::ChangeFileLockL() (1): Store opened.");
}
else if ( aFlags != ETakeLock )
{
CBSLOGSTRING("CBSSERVER: CCbsDbImpTopicList::ChangeFileLockL() (1): Deleting iTopicStore...");
delete iTopicStore;
iTopicStore = NULL;
CBSLOGSTRING("CBSSERVER: CCbsDbImpTopicList::ChangeFileLockL() (1): iTopicStore deleted.");
}
CBSLOGSTRING("CBSSERVER: <<< CCbsDbImpTopicList::ChangeFileLockL() (1)");
}
#else
// -----------------------------------------------------------------------------
// CCbsDbImpSettings::ChangeFileLockL
// Closes or reopens the settings file if requested by backup.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::ChangeFileLockL( const TCbsBackupRequest& aRequest )
{
CBSLOGSTRING2("CBSSERVER: >>> CCbsDbImpTopicList::ChangeFileLockL() (2): aRequest: %d", aRequest );
// If backing up or restoring, release locks
if ( ( aRequest == ECbsBackup ||
aRequest == ECbsRestore ) )
{
delete iTopicStore;
iTopicStore = NULL;
CBSLOGSTRING("CBSSERVER: CCbsDbImpTopicList::ChangeFileLockL() (2): iTopicStore deleted.");
}
// Else take files into use again
else if ( ( aRequest == ECbsNoBackup ||
aRequest == ECbsBackupNotDefined ) &&
iTopicStore == NULL)
{
CBSLOGSTRING("CBSSERVER: CCbsDbImpTopicList::ChangeFileLockL() (2): Calling CPermanentFileStore::OpenL()...");
// Try to open the store.
iTopicStore = CPermanentFileStore::OpenL( iFs,
iTopicsFilename->Des(), EFileRead | EFileWrite );
CBSLOGSTRING("CBSSERVER: CCbsDbImpTopicList::ChangeFileLockL() (2): CPermanentFileStore::OpenL() finished.");
}
CBSLOGSTRING("CBSSERVER: <<< CCbsDbImpTopicList::ChangeFileLockL() (2)");
}
#endif
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::CheckFileLockL
// Check if the server has a file lock.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::CheckFileLockL() const
{
CBSLOGSTRING("CBSSERVER: >>> CCbsDbImpTopicList::CheckFileLockL()");
if ( iTopicStore == NULL )
{
CBSLOGSTRING("CBSSERVER: CCbsDbImpTopicList::CheckFileLockL(): iTopicStore == NULL, leaving with KErrLocked...");
User::Leave( KErrLocked );
}
CBSLOGSTRING("CBSSERVER: <<< CCbsDbImpTopicList::CheckFileLockL()");
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::CreateNewTopicListL
// Creates a new topic list.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::CreateNewTopicListL( const TDesC& aTopicListName )
{
// FFS critical level check
CbsUtils::FFSCriticalLevelCheckL( KTopicListStreamSize +
KCbsDbTopicArraySize, iFs );
TInt topicListCount = iTopicLists->Count();
// Check if there already is 10 topic lists
if ( topicListCount < KCbsRootItemsSize )
{
// Create the stream for this topic list entry
RStoreWriteStream outstream;
TStreamId topicListStreamId(
outstream.CreateLC( *TopicStoreL() ) ); // on CS
// Set the values for this new topic list and set it as "current".
// Reset the topic count of this topic list.
iCurrentTopicList.iTopicCount = 0;
// Topic list stream id for this list
iCurrentTopicList.iTopicListId = topicListStreamId;
// List name
iCurrentTopicList.iTopicListName = aTopicListName;
// Is this the default list
iCurrentTopicList.iIsDefaultTopicList = ETrue;
// Number of this list, which is a int value between 0...9
iCurrentTopicList.iNumber = iTopicLists->Count();
// Add this list to the list array
TKeyArrayFix key( _FOFF( TCbsDbImpTopicList, iNumber ), ECmpTUint16 );
iTopicLists->InsertIsqL( iCurrentTopicList, key );
// Write the values to this topic list's stream
outstream << iCurrentTopicList.iTopicListName;
CbsStreamHelper::WriteBoolL( outstream, iCurrentTopicList.iIsDefaultTopicList );
outstream.WriteInt16L( iCurrentTopicList.iNumber );
outstream.WriteInt16L( iCurrentTopicList.iTopicCount );
// Write space for topic stream IDs
for ( TInt i( 0 ); i < KCbsDbTopicArraySize; i++ )
{
outstream << TStreamId( 0 );
}
outstream.CommitL();
CleanupStack::PopAndDestroy(); // outstream
// Reset the topic array and add an index topic to this
// topic list
iTopics->Reset();
AddIndexTopicL();
// Update the root stream
UpdateRootStreamL( EFalse );
// Commit file changes
CommitFilesL();
// Load the topics (count = 1, Index topic only),
// so that the array is up to date
LoadTopicsL( iCurrentTopicList.iTopicListId );
}
else
{
User::Leave( KErrGeneral );
}
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::SetTopicMessages
// Sets the topic messages db object for this topic list.
// Note that this function does not transfer ownership
// of aMessages.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::SetTopicMessages(
CCbsDbImpTopicMessages* aMessages )
{
__ASSERT_ALWAYS( aMessages != NULL,
CbsServerPanic( ECbsTopicMessagesNull ) );
iMessages = aMessages;
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::TopicCount
// Returns the total amount of topics the list contains.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CCbsDbImpTopicList::TopicCount() const
{
return iTopics->Count();
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::TopicListCount
// Get topic list count.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CCbsDbImpTopicList::TopicListCount() const
{
return iTopicLists->Count();
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::TopicStoreL
// Returns pointer to the current store which contains topics
// of the server (i.e., Topics-file) and saved messages.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
CFileStore* CCbsDbImpTopicList::TopicStoreL() const
{
CheckFileLockL();
return iTopicStore;
}
// ---------------------------------------------------------
// TopicFilename()
//
// ---------------------------------------------------------
const TDesC& CCbsDbImpTopicList::TopicFilename() const
{
return *iTopicsFilename;
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::UnsavedMessagesStore
// Returns a pointer to the store, which contains unsaved
// messages of the server (Unsaved Messages-file, "cbs4.dat").
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
CFileStore* CCbsDbImpTopicList::UnsavedMessagesStore() const
{
return iUnsavedMessageStore;
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::UnsavedMessagesFilename
// Returns a reference to the name of the file, which contains unsaved
// messages of the server (Unsaved Messages-file, "cbs4.dat").
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
const TDesC& CCbsDbImpTopicList::UnsavedMessagesFilename() const
{
return *iUnsavedMessagesFilename;
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::ExtractTopicNumber
// Extracts topic handle from message handle.
// Note that the method does not check that the message exists.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TCbsDbTopicNumber CCbsDbImpTopicList::ExtractTopicNumber(
const TCbsDbMessageHandle& aHandle ) const
{
return TCbsDbTopicNumber( aHandle >> 16 );
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::GetTopicMessagesIdL
// Returns the topic messages stream id by topic handle.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::GetTopicMessagesIdL(
TCbsDbTopicNumber aNumber, TStreamId& aId ) const
{
CBSLOGSTRING("CBSSERVER: >>> CCbsDbImpTopicList::GetTopicMessagesIdL()");
// Find the topic.
TInt index( TopicIndexInList( aNumber ) );
CBSLOGSTRING2("CBSSERVER: CCbsDbImpTopicList::GetTopicMessagesIdL(): Leaving if index != 0. Index: %d.", index );
User::LeaveIfError( index );
// Return the topic message stream id.
aId = iTopics->At( index ).iTopicMessagesId;
CBSLOGSTRING("CBSSERVER: <<< CCbsDbImpTopicList::GetTopicMessagesIdL()");
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::UpdateTopicMessagesIdL
// Updates the topic messages stream id by topic handle.
// The new identifier is expected not to be a null id.
// Note that the method will not commit changes to the store.
// It also changes the internal state and thus if the method leaves,
// it is good to reload the whole root stream.
// The method will delete the old topic messages stream.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::UpdateTopicMessagesIdL(
TCbsDbTopicNumber aNumber,
const TStreamId& aNewId )
{
__TEST_INVARIANT;
// Find position.
TInt index( TopicIndexInList( aNumber ) );
User::LeaveIfError( index );
// Get the old id.
TStreamId oldId( iTopics->At( index ).iTopicMessagesId );
// Get the topic information.
TCbsDbTopic topic;
GetTopicL( index, topic );
// Write information to the stream.
RStoreWriteStream outstream;
outstream.OpenLC( *TopicStoreL(), iTopics->At( index ).iTopicId ); // on CS
WriteTopicInformationL( outstream, topic, aNewId );
outstream.CommitL();
CleanupStack::PopAndDestroy();
// Delete the old stream.
TopicStoreL()->DeleteL( oldId );
// Update the topic messages id.
iTopics->At( index ).iTopicMessagesId = aNewId;
__TEST_INVARIANT;
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::GenerateMessageHandle
// Generates a new message handle using the topic
// handle of the message and a given random value.
// Note that it must be checked that the message handle is unique
// in that topic.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TCbsDbMessageHandle CCbsDbImpTopicList::GenerateMessageHandle(
const TCbsDbTopicNumber aNumber,
TUint16 aRandom ) const
{
return ( aNumber << 16 ) + aRandom;
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::ReloadRootStreamL
// Reloads the root stream to the memory.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::ReloadRootStreamL()
{
LoadRootStreamL();
__TEST_INVARIANT;
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::InformNewMessageReceivedL
// Informs that a new message has been received in a topic.
// This method is called by CCbsDbImpTopicMessages. After internal
// records are changed, the observers are informed of this event.
// Note: leaves changes in stores uncommited.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::InformNewMessageReceivedL(
const TCbsDbMessageHandle& aMessageHandle )
{
__TEST_INVARIANT;
// Find topic by handle.
TCbsDbTopicNumber number( ExtractTopicNumber( aMessageHandle ) );
TCbsDbTopic topic;
FindTopicByNumberL( number, topic );
topic.iUnreadMessages++;
// Increase the counter in cache
TInt position = TopicIndexInList( topic.iNumber );
iTopics->At( position ).iTopicData.iUnreadMessages++;
// Write topic information to topic stream but leave changes uncommited.
UpdateTopicCountersL( topic, EFalse );
if ( topic.iHotmarked )
{
SetHotmarkedMessage( aMessageHandle );
}
__TEST_INVARIANT;
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::InformMessageSavedL
// Informs that a message has been set as saved.
// Updates the saved messages counters
// for the topic of the message and the whole system.
// Called by CCbsDbTopicMessages.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::InformMessageSavedL(
const TCbsDbMessageHandle& aMessageHandle )
{
__TEST_INVARIANT;
// Find topic by handle.
TCbsDbTopicNumber number( ExtractTopicNumber( aMessageHandle ) );
TCbsDbTopic topic;
FindTopicByNumberL( number, topic );
topic.iSavedMessages++;
// Increase the counter in cache
TInt position = TopicIndexInList( topic.iNumber );
iTopics->At( position ).iTopicData.iSavedMessages++;
// Write topic information to topic stream but leave changes uncommited.
UpdateTopicCountersL( topic, EFalse );
__TEST_INVARIANT;
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::InformUnreadMessageReadL
// Informs that an unread message has been read.
// Updates the counters when a message is read by the client.
// Note: leaves changes in stores uncommited.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::InformUnreadMessageReadL(
const TCbsDbMessageHandle& aMessageHandle )
{
CBSLOGSTRING("CBSSERVER: >>> CCbsDbImpTopicList::InformUnreadMessageReadL()");
__TEST_INVARIANT;
// Check for file lock
CheckFileLockL();
// Check disk space
TRAPD( error, CbsUtils::FFSCriticalLevelCheckL( KReadMessageSize, iFs ) );
CBSLOGSTRING2("CBSSERVER: CCbsDbImpTopicList::InformUnreadMessageReadL(): FFSCriticalLevelCheckL returned: %d", error );
if ( error == KErrDiskFull )
{
return;
}
// Find topic by number.
TCbsDbTopicNumber number( ExtractTopicNumber( aMessageHandle ) );
TCbsDbTopic topic;
FindTopicByNumberL( number, topic );
// Decrease the counter
topic.iUnreadMessages--;
// Decrease the counter in cache
TInt position = TopicIndexInList( topic.iNumber );
iTopics->At( position ).iTopicData.iUnreadMessages--;
// Write topic information to topic stream but leave changes uncommited.
UpdateTopicCountersL( topic, EFalse );
__TEST_INVARIANT;
CBSLOGSTRING("CBSSERVER: <<< CCbsDbImpTopicList::InformUnreadMessageReadL()");
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::InformMessageDeletedL
// Informs that an unread message has been deleted.
// Updates the counters when a message is deleted.
// Note: leaves changes in stores uncommited.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::InformMessageDeletedL(
const TCbsDbMessageHandle& aMessageHandle,
TBool aPermanent,
TBool aRead )
{
// Find topic by handle.
TCbsDbTopicNumber number( ExtractTopicNumber( aMessageHandle ) );
TCbsDbTopic topic;
FindTopicByNumberL( number, topic );
TInt position = TopicIndexInList( topic.iNumber );
if ( aPermanent )
{
topic.iSavedMessages--;
iTopics->At( position ).iTopicData.iSavedMessages--;
}
if ( !aRead )
{
topic.iUnreadMessages--;
iTopics->At( position ).iTopicData.iUnreadMessages--;
}
// Write topic information to topic stream but leave changes uncommited.
UpdateTopicCountersL( topic, ETrue );
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::TotalSavedMessages
// Returns the number of saved messages in the current topic list.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CCbsDbImpTopicList::TotalSavedMessages() const
{
// Return the total amount of saved messages.
TInt count( 0 );
for ( TInt i( 0 ); i < iTopics->Count(); i++ )
{
count += iTopics->At( i ).iTopicData.iSavedMessages;
}
return count;
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::GetTopicCount
// Returns the number of topic stored in this topic list.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::GetTopicCount(
TInt& aCount ) const
{
// Return the total amount of topics.
aCount = TopicCount();
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::InitializeListL
// Initializes the whole topic list.
// Creates and opens the topic list file,
// invalidates the cache and informs the observers.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::InitializeListL( const TBool aFileOpenFailed )
{
__TEST_INVARIANT;
if ( !aFileOpenFailed )
{
// Check for file lock
CheckFileLockL();
}
// About to write to FFS: make critical level check
CbsUtils::FFSCriticalLevelCheckL( 0, iFs );
if ( iMessages != NULL && iMessages->IsLockedMessages() )
{
User::Leave( KErrAccessDenied );
}
// If only one topic list exists, just delete and recreate the whole file
if ( iTopicLists->Count() == 1 || aFileOpenFailed == 1 )
{
delete iTopicStore;
iTopicStore = NULL;
delete iUnsavedMessageStore;
iUnsavedMessageStore = NULL;
CbsUtils::DeleteFileL( iFs, *iTopicsFilename );
CbsUtils::DeleteFileL( iFs, *iUnsavedMessagesFilename );
iTopicLists->Reset();
// Create new files.
OpenFilesL( EFalse, ETrue );
}
iIsHotmarkedMessage = EFalse;
iLastTopicNumber = 0;
iMessageHandle = 0;
// Inform the message manager.
if ( iMessages )
{
iMessages->InvalidateCache();
}
// Notify everyone.
NotifyTopicListInitializedL();
__TEST_INVARIANT;
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::GetTopicL
// Returns a topic matching the given index.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::GetTopicL(
TInt aIndex,
TCbsDbTopic& aTopic )
{
CBSLOGSTRING("CBSSERVER: >>> CCbsDbImpTopicList::GetTopicL()");
__TEST_INVARIANT;
// Check that aIndex is in proper range.
if ( ( aIndex < 0 ) || ( aIndex >= iTopics->Count() ) )
{
CBSLOGSTRING("CBSSERVER: CCbsDbImpTopicList::GetTopicL(): Leaving with KErrArgument...");
User::Leave( KErrArgument );
}
// And then get the information from the array.
aTopic = iTopics->At( aIndex ).iTopicData;
CBSLOGSTRING("CBSSERVER: <<< CCbsDbImpTopicList::GetTopicL()");
__TEST_INVARIANT;
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::FindTopicByNumberL
// Returns a topic matching the given topic number
// (in GSM Specs this is called the Message Identifier)
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::FindTopicByNumberL(
TCbsDbTopicNumber aNumber,
TCbsDbTopic& aTopic )
{
CBSLOGSTRING("CBSSERVER: >>> CCbsDbImpTopicList::FindTopicByNumberL()");
__TEST_INVARIANT;
TInt topicIndex( TopicIndexInList( aNumber ) );
CBSLOGSTRING2("CBSSERVER: CCbsDbImpTopicList::FindTopicByNumberL(): Leaving if topicIndex < 0: topicIndex: %d.", topicIndex );
User::LeaveIfError( topicIndex );
GetTopicL( topicIndex, aTopic );
CBSLOGSTRING("CBSSERVER: <<< CCbsDbImpTopicList::FindTopicByNumberL()");
__TEST_INVARIANT;
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::AddTopicL
// Adds a new topic to the list.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::AddTopicL(
TCbsDbTopic& aTopic, const TBool aDetected )
{
__TEST_INVARIANT;
// Check for file lock
CheckFileLockL();
// Check that topic number is in proper range
if ( !CheckTopicNumber( aTopic.iNumber ) )
{
User::Leave( KErrArgument );
}
// Check if there is a topic with the
// same topic number in current topic list.
if ( TopicIndexInList( aTopic.iNumber ) != KErrNotFound )
{
User::Leave( KErrAlreadyExists );
}
// There should not be any saved or unread messages
aTopic.iSavedMessages = 0;
aTopic.iUnreadMessages = 0;
// Variated feature. Also, only topics that were not detected automatically
// are subscribed by default.
if ( iLVBits & KCbsLVFlagTopicSubscription && !aDetected )
{
aTopic.iSubscribed = ETrue;
}
else
{
aTopic.iSubscribed = EFalse;
}
// Now we have the handle, so let's add the topic.
TRAPD( error, DoAddTopicL( aTopic ) );
if ( error != KErrNone )
{
RevertFilesL();
__TEST_INVARIANT;
User::Leave( error );
}
else
{
iLastTopicNumber = aTopic.iNumber;
NotifyTopicAddedL( aTopic.iNumber );
}
__TEST_INVARIANT;
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::UpdateTopicNameAndNumberL
// Updates the name and the topic number of a topic
// matching the given handle to the database.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::UpdateTopicNameAndNumberL(
TCbsDbTopicNumber aOldNumber,
TCbsDbTopicNumber aNewNumber,
const TCbsDbTopicName& aName )
{
// Check for file lock
CheckFileLockL();
// First, check that the new number is ok.
if ( !CheckTopicNumber( aNewNumber ) )
{
User::Leave( KErrArgument );
}
// First find and then update.
TCbsDbTopic topic;
FindTopicByNumberL( aOldNumber, topic );
// If no changes to topic, no need to update
if ( !( aOldNumber == aNewNumber && topic.iName == aName ) )
{
if ( topic.iProtected )
{
User::Leave( KErrAccessDenied );
}
topic.iName = aName;
topic.iNumber = aNewNumber;
UpdateTopicL( aOldNumber, topic );
}
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::UpdateTopicSubscriptionStatusL
// Updates the new topic subscription status to the database.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::UpdateTopicSubscriptionStatusL(
TCbsDbTopicNumber aNumber,
TBool aStatus )
{
__TEST_INVARIANT;
// Update topic subsciption status.
TCbsDbTopic topic;
FindTopicByNumberL( aNumber, topic );
topic.iSubscribed = aStatus;
UpdateTopicL( aNumber, topic );
__TEST_INVARIANT;
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::UpdateTopicHotmarkStatusL
// Updates the new topic hotmarking status to the database.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::UpdateTopicHotmarkStatusL(
TCbsDbTopicNumber aNumber,
TBool aStatus )
{
__TEST_INVARIANT;
// Check for file lock
CheckFileLockL();
// Update topic hotmark status.
TCbsDbTopic topic;
FindTopicByNumberL( aNumber, topic );
topic.iHotmarked = aStatus;
UpdateTopicL( aNumber, topic );
__TEST_INVARIANT;
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::DeleteTopicL
// Deletes an existing topic and all its messages.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::DeleteTopicL(
TCbsDbTopicNumber aNumber )
{
__TEST_INVARIANT;
// Try to find the position. If it is not found, leave.
TInt position( TopicIndexInList( aNumber ) );
User::LeaveIfError( position );
// Check that there are no locked messages in the topic.
if ( iMessages->IsLockedMessagesInTopic( aNumber ) )
{
User::Leave( KErrAccessDenied );
}
// Topic only in one topic list, not an index topic, so delete the topic.
if ( aNumber != 0 )
{
// Just try to delete
TRAPD( error, DoDeleteTopicL( position ) );
if ( error != KErrNone )
{
// It failed, so we must revert.
RevertFilesL();
// Inform the topic messages.
iMessages->InvalidateCacheIfTopic( aNumber );
__TEST_INVARIANT;
User::Leave( error );
}
else
{
// Notify the observers
NotifyTopicDeletedL( aNumber );
}
}
__TEST_INVARIANT;
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::GetUnreadMessageCount
// Gets the total amount of unread messages.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::GetUnreadMessageCount(
TInt& aCount ) const
{
CBSLOGSTRING("CBSSERVER: >>> CCbsDbImpTopicList::GetUnreadMessageCount()");
CBSLOGSTRING2("CBSSERVER: CCbsDbImpTopicList::GetUnreadMessageCount(): Topic count: %d", iTopics->Count() );
// Return the total amount of unread messages.
TInt count( 0 );
for ( TInt i( 0 ); i < iTopics->Count(); i++ )
{
count += iTopics->At( i ).iTopicData.iUnreadMessages;
}
aCount = count;
CBSLOGSTRING2("CBSSERVER: CCbsDbImpTopicList::GetUnreadMessageCount(): Unread msgs found: %d", count );
CBSLOGSTRING("CBSSERVER: <<< CCbsDbImpTopicList::GetUnreadMessageCount()");
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::GetHotmarkedMessageHandleL
// Returns the handle to the latest hotmarked message.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::GetHotmarkedMessageHandleL(
TCbsDbMessageHandle& aMessage )
{
__TEST_INVARIANT;
// Check if there is a hotmarked message.
if ( iIsHotmarkedMessage )
{
// If there is, then return it.
aMessage = iMessageHandle;
iIsHotmarkedMessage = EFalse;
}
else
{
// Otherwise leave.
__TEST_INVARIANT;
User::Leave( KErrNotFound );
}
__TEST_INVARIANT;
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::UnreadHotmarkedMessageCount
// Returns the handle to the latest hotmarked message.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CCbsDbImpTopicList::UnreadHotmarkedMessageCount() const
{
// Return the total amount of unread messages in hotmarked topics.
TInt count( 0 );
for ( TInt i( 0 ); i < iTopics->Count(); i++ )
{
TCbsDbTopic& topic = iTopics->At( i ).iTopicData;
if ( topic.iHotmarked )
{
count += topic.iUnreadMessages;
}
}
return count;
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::AddObserverL
// Adds a topic list observer.
// After an observer is added to the topic list,
// it will be notified whenever an event occurs.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::AddObserverL(
MCbsDbTopicListObserver* aObserver )
{
__ASSERT_DEBUG( aObserver != 0, CbsServerPanic( ECbsObserverNull ) );
iObservers->AppendL( aObserver );
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::RemoveObserver
// Removes a topic list observer.
// If aObserver is not in the list, the method will panic.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::RemoveObserver(
const MCbsDbTopicListObserver* aObserver )
{
__TEST_INVARIANT;
__ASSERT_DEBUG( aObserver != 0, CbsServerPanic( ECbsObserverNull ) );
TBool observerFound( EFalse );
TInt amountOfObservers( iObservers->Count() );
// Check if the observer exists and
// find its possible location index in the array.
for ( TInt index( 0 ); ( index < amountOfObservers ) && !observerFound; index++ )
{
if ( aObserver == iObservers->At( index ) )
{
iObservers->Delete( index );
observerFound = ETrue;
}
}
__TEST_INVARIANT;
#ifdef _DEBUG
if ( !observerFound )
{
CbsServerPanic( ECbsObserverNotFound );
}
#endif
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::TopicIndexInList
// Finds the index of the topic matching the given topic number
// in the topic list.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CCbsDbImpTopicList::TopicIndexInList(
TCbsDbTopicNumber aNumber ) const
{
// Create a TCbsDbImpTopic to compare against and use a binary search.
TKeyArrayFix key( _FOFF( TCbsDbImpTopic, iTopicData.iNumber ), ECmpTUint16 );
TCbsDbImpTopic dummy;
TInt position;
dummy.iTopicData.iNumber = aNumber;
TInt result( iTopics->FindIsq( dummy, key, position ) );
if ( result != KErrNone )
{
position = KErrNotFound;
}
return position;
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::GetNextAndPrevTopicNumberL
// Retrieves numbers of topics that precede and succeed the topic
// with number aCurrentTopic.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::GetNextAndPrevTopicNumberL(
const TCbsTopicNumber& aCurrentTopic,
TCbsTopicNumber& aNextTopic,
TCbsTopicNumber& aPrevTopic,
TInt& aPosition )
{
// Determine position of requested topic in topic list.
TInt index( TopicIndexInList( aCurrentTopic ) );
User::LeaveIfError( index ); // if KErrNotFound
// Determine position indications
aPosition = 0;
if ( index == 0 )
{
aPosition |= ECbsHead;
}
else
{
aPrevTopic = iTopics->At( index-1 ).iTopicData.iNumber;
}
if ( index == iTopics->Count()-1 )
{
aPosition |= ECbsTail;
}
else
{
aNextTopic = iTopics->At( index+1 ).iTopicData.iNumber;
}
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::NotifyNewMessageArrivedL
// Notifies each observer that a new message has arrived to a topic.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::NotifyNewMessageArrivedL(
const TCbsDbMessageHandle& aHandle )
{
// Notify each observer.
TInt count( iObservers->Count() );
for ( TInt index( 0 ); index < count; index++ )
{
iObservers->At( index )->TopicNewMessageReceivedIndL( aHandle );
}
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::AppendSubscribedTopicsL
// Adds numbers of subscribed topics to the given array.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::AppendSubscribedTopicsL(
CArrayFixFlat<TUint16>& aSubscriptions ) const
{
TInt count( iTopics->Count() );
for ( TInt i( 0 ); i < count; i++ )
{
TCbsDbImpTopic& topic = iTopics->At( i );
if ( topic.iTopicData.iSubscribed )
{
aSubscriptions.AppendL( topic.iTopicData.iNumber );
}
}
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::LoadRootStreamL
// Loads the root stream to the memory.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::LoadRootStreamL()
{
__ASSERT_DEBUG( iTopicLists != NULL,
CbsServerPanic( ECbsTopicListArrayNull ) );
// Get the root stream and open it.
TStreamId id( TopicStoreL()->Root() );
RStoreReadStream instream;
instream.OpenLC( *TopicStoreL(), id ); // on CS
// Load the topic list count
TInt topicListCount( instream.ReadInt16L() );
// Sanity check
if ( topicListCount < 0 )
{
User::Leave( KErrCorrupt );
}
// Reset the topic list array
iTopicLists->Reset();
// Load the topic list information
TCbsDbImpTopicList item;
instream >> item.iTopicListId;
ReadTopicListInformationL( item.iTopicListId, item );
iTopicLists->AppendL( item );
// Destroy the stream.
CleanupStack::PopAndDestroy(); // instream
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::LoadDefaultTopicStreamL
// Loads the default topic list to the memory.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::LoadDefaultTopicStreamL()
{
__ASSERT_DEBUG( iTopics != NULL,
CbsServerPanic( ECbsTopicListArrayNull ) );
// Read root item count
TInt topicListCount = iTopicLists->Count();
// If there isn't any, create a topic list for standard topics here
if ( topicListCount == 0 )
{
CreateStandardTopicListL();
topicListCount = iTopicLists->Count();
}
TStreamId defaultTopicListId( 0 );
TBool quitSearch( EFalse );
TInt i;
// Find the default topic list
for ( i = 0; ( i < topicListCount ) && !quitSearch; ++i )
{
if ( iTopicLists->At( i ).iIsDefaultTopicList )
{
defaultTopicListId = iTopicLists->At( i ).iTopicListId;
quitSearch = ETrue;
}
}
CArrayFixFlat< TStreamId >* topicIds =
new ( ELeave ) CArrayFixFlat< TStreamId >( KTopicIdsGranularity );
// Open the default topic list stream
RStoreReadStream instream;
instream.OpenLC( *TopicStoreL(), defaultTopicListId ); // on CS
// Set the ID
iCurrentTopicList.iTopicListId = defaultTopicListId;
// Set the name
HBufC* topicListName = HBufC::NewL( instream, KCbsDbTopicNameLength );
iCurrentTopicList.iTopicListName.Copy( topicListName->Des() );
delete topicListName;
topicListName = NULL;
// Skip default list status, since it is always true in default topic list
CbsStreamHelper::ReadBoolL( instream );
iCurrentTopicList.iIsDefaultTopicList = ETrue;
// Set the topic list number
iCurrentTopicList.iNumber = instream.ReadInt16L();
// Read the amount of topics
TInt topicCount = instream.ReadInt16L();
iCurrentTopicList.iTopicCount = topicCount;
// Clear the topic array.
iTopics->ResizeL( 0 );
TStreamId id( 0 );
// Load the topic IDs
for ( i = 0; i < topicCount; i++ )
{
instream >> id;
topicIds->AppendL( id );
}
// Destroy the stream.
CleanupStack::PopAndDestroy();
// Load necessary information for each topic
TInt count = topicIds->Count();
TCbsDbImpTopic topic;
for ( i = 0; i < count; i++ )
{
ReadTopicInformationL( topicIds->At( i ), topic );
if ( topic.iTopicData.iNumber == KIndexTopicNumber )
{
HBufC* indexName = ReadIndexTopicNameLC(); // on CS
topic.iTopicData.iName.Copy( *indexName );
CleanupStack::PopAndDestroy(); // indexName
}
iTopics->AppendL( topic );
}
delete topicIds;
topicIds = NULL;
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::ReadTopicListInformationL
// Reads topic list information from stream.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::ReadTopicListInformationL(
const TStreamId& aId,
TCbsDbImpTopicList& aTopicList ) const
{
RStoreReadStream instream;
instream.OpenLC( *TopicStoreL(), aId ); // on CS
// Topic List name
HBufC* topicListName = HBufC::NewL( instream, KCbsDbTopicNameLength );
aTopicList.iTopicListName.Copy( topicListName->Des() );
delete topicListName;
topicListName = NULL;
// Default list status
aTopicList.iIsDefaultTopicList = CbsStreamHelper::ReadBoolL( instream );
// Topic List number
aTopicList.iNumber = instream.ReadInt16L();
// Topic count of this topic list
aTopicList.iTopicCount = instream.ReadInt16L();
CleanupStack::PopAndDestroy(); // instream
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::ReadTopicInformationL
// Reads all information on topic found in stream aId
// into aTopic.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::ReadTopicInformationL(
const TStreamId& aId,
TCbsDbImpTopic& aTopic ) const
{
RStoreReadStream instream;
instream.OpenLC( *TopicStoreL(), aId ); // on CS
// Topic ID
aTopic.iTopicId = aId;
// Read saved messages.
aTopic.iTopicData.iSavedMessages = instream.ReadInt16L();
// Read name.
instream >> aTopic.iTopicData.iName;
// Read topic number (message identifier)
aTopic.iTopicData.iNumber = instream.ReadInt16L();
// Read statuses
aTopic.iTopicData.iProtected = CbsStreamHelper::ReadBoolL( instream ); // Protected
aTopic.iTopicData.iSubscribed = CbsStreamHelper::ReadBoolL( instream );// Subscribed
aTopic.iTopicData.iHotmarked = CbsStreamHelper::ReadBoolL( instream ); // Hotmarked
// Read unread messages count
aTopic.iTopicData.iUnreadMessages = instream.ReadInt16L();
// Topic messages' stream ID
instream >> aTopic.iTopicMessagesId;
// Sanity check
if ( aTopic.iTopicData.iSavedMessages > KCbsDbMaxSavedMessages
|| aTopic.iTopicData.iNumber > KCbsMaxValidTopicNumber
|| aTopic.iTopicData.iUnreadMessages > KCbsDbMaxReceivedMessages )
{
User::Leave( KErrCorrupt );
}
CleanupStack::PopAndDestroy(); // instream
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::DoAddTopicL
// Adds a topic into the database.
// Assumes aTopic is not a duplicate.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::DoAddTopicL(
const TCbsDbTopic& aTopic )
{
// About to write to FFS: make critical level check
CbsUtils::FFSCriticalLevelCheckL( KTopicStreamSize +
KEmptyTopicMessagesStreamSize, iFs );
// Generate general information about topic.
TCbsDbImpTopic topic;
topic.iTopicData = aTopic;
// Write stream for messages.
topic.iTopicMessagesId =
CCbsDbImpTopicMessages::CreateDefaultTopicMessagesStreamL(
*TopicStoreL() );
// Create stream for topic information.
RStoreWriteStream outstream;
topic.iTopicId = outstream.CreateLC( *TopicStoreL() ); // on CS
WriteTopicInformationL( outstream, aTopic, topic.iTopicMessagesId );
outstream.CommitL();
CleanupStack::PopAndDestroy(); // outstream
// Now, insert the new topic information to the array
TKeyArrayFix key( _FOFF( TCbsDbImpTopic, iTopicData.iNumber ), ECmpTUint16 );
iTopics->InsertIsqL( topic, key );
// Update the topic list stream
UpdateTopicListStreamL( iCurrentTopicList, EFalse );
// We have modified only iTopicStore, so if CommitFilesL() leaves,
// we either get all committed or nothing committed.
CommitFilesL();
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::DoUpdateTopicL
// Updates the data for a topic into the database.
// The position of the topic in the list is
// changed if necessary.
// If the position has to be changed, the handles of messages
// contained in the topic have to be changed as well because
// the high word of the handle identifies the topic by it's
// number.
// Please note that standard EPOC DoSomethingL protocol
// is not followed here as this function does NOT commit
// changes made to the store. Instead, the caller must ensure
// use of proper commit/revert operations.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::DoUpdateTopicL(
const TCbsDbTopic& aTopic,
TBool aNeedToChange,
TInt aOldPosition,
TBool aDeleting )
{
CBSLOGSTRING("CBSSERVER: >>> CCbsDbImpTopicList::DoUpdateTopicL()");
RSharedDataClient sharedData;
// About to write to FFS: make critical level check
if ( aDeleting )
{
User::LeaveIfError( sharedData.Connect() );
sharedData.RequestFreeDiskSpaceLC( KTopicStreamSize ); // on CS
}
else
{
CbsUtils::FFSCriticalLevelCheckL( KTopicStreamSize, iFs );
}
TInt newPosition( aOldPosition );
// If there is need to change position, change it.
if ( aNeedToChange )
{
TCbsDbImpTopic topic( iTopics->At( aOldPosition ) );
// Adjust handles of topic messages to match the changed topic number.
iMessages->UpdateHandlesOfTopicMessagesL(
topic.iTopicData.iNumber, aTopic.iNumber );
// Delete topic from the array.
iTopics->Delete( aOldPosition );
// Set the number and reinsert into array
topic.iTopicData.iNumber = aTopic.iNumber;
TKeyArrayFix key( _FOFF( TCbsDbImpTopic, iTopicData.iNumber ), ECmpTUint16 );
newPosition = iTopics->InsertIsqL( topic, key );
}
iTopics->At( newPosition ).iTopicData.iSubscribed = aTopic.iSubscribed;
iTopics->At( newPosition ).iTopicData.iHotmarked = aTopic.iHotmarked;
iTopics->At( newPosition ).iTopicData.iName = aTopic.iName;
iTopics->At( newPosition ).iTopicData.iSavedMessages = aTopic.iSavedMessages;
iTopics->At( newPosition ).iTopicData.iUnreadMessages = aTopic.iUnreadMessages;
// Replace existing stream.
RStoreWriteStream outstream;
outstream.ReplaceLC( *TopicStoreL(),
iTopics->At( newPosition ).iTopicId ); // on CS
WriteTopicInformationL( outstream, aTopic,
iTopics->At( newPosition ).iTopicMessagesId );
outstream.CommitL();
CleanupStack::PopAndDestroy(); // outstream
// Free the reserved space
if ( aDeleting )
{
CleanupStack::PopAndDestroy(); // disk space
sharedData.Close();
}
// Update topic list stream, if necessary.
if ( aNeedToChange )
{
UpdateTopicListStreamL( iCurrentTopicList, EFalse );
}
CBSLOGSTRING("CBSSERVER: <<< CCbsDbImpTopicList::DoUpdateTopicL()");
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::DoDeleteTopicL
// Deletes a topic from the given position in the database.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::DoDeleteTopicL(
TInt aPosition )
{
// Check that the topic is not protected.
TCbsDbTopic topic;
GetTopicL( aPosition, topic );
// It is not allowed to delete a topic that is protected. It must
// first be updated to be not protected.
if ( topic.iProtected )
{
User::Leave( KErrAccessDenied );
}
// First delete all messages the topic contains.
RStoreReadStream instream;
instream.OpenLC( *TopicStoreL(),
iTopics->At( aPosition ).iTopicMessagesId ); // on CS
CCbsDbImpTopicMessages::DeleteAllTopicMessagesL( *TopicStoreL(),
*iUnsavedMessageStore, instream );
iMessages->InvalidateCache();
CleanupStack::PopAndDestroy(); // instream
// Delete topic and topic messages streams.
TopicStoreL()->DeleteL( iTopics->At( aPosition ).iTopicMessagesId );
TopicStoreL()->DeleteL( iTopics->At( aPosition ).iTopicId );
// Remove from the internal cache.
iTopics->Delete( aPosition );
iCurrentTopicList.iTopicCount--;
UpdateTopicListStreamL( iCurrentTopicList, ETrue );
CommitFilesL();
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::UpdateRootStreamL
// Updates the root stream.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::UpdateRootStreamL(
TBool aDeleting )
{
// Check the free space
TInt neededSpace( KTopicListRootStreamSize + iTopicLists->Count() * 2 );
RSharedDataClient sharedData;
// About to write to FFS: make critical level check
if ( aDeleting )
{
User::LeaveIfError( sharedData.Connect() );
sharedData.RequestFreeDiskSpaceLC( neededSpace ); // on CS
}
else
{
CbsUtils::FFSCriticalLevelCheckL( neededSpace, iFs );
}
// Now there is room for all topics. So we can just replace.
RStoreWriteStream outstream;
outstream.ReplaceLC( *TopicStoreL(), TopicStoreL()->Root() ); // on CS
// Write root stream
WriteRootStreamL( outstream );
CleanupStack::PopAndDestroy(); // outstream
// Free the reserved space
if ( aDeleting )
{
CleanupStack::PopAndDestroy(); // disk space
sharedData.Close();
}
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::UpdateTopicListStreamL
// Updates topic list stream.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::UpdateTopicListStreamL(
TCbsDbImpTopicList& aTopicList,
TBool aDeleting )
{
TInt neededSpace( KTopicListStreamSize + iTopics->Count() * 2 );
RSharedDataClient sharedData;
// About to write to FFS: make critical level check
if ( aDeleting )
{
User::LeaveIfError( sharedData.Connect() );
sharedData.RequestFreeDiskSpaceLC( neededSpace ); // on CS
}
else
{
CbsUtils::FFSCriticalLevelCheckL( neededSpace, iFs );
}
// Replace the stream
RStoreWriteStream outstream;
outstream.ReplaceLC( *TopicStoreL(), aTopicList.iTopicListId ); // on CS
// Write root stream
WriteTopicListStreamL( outstream, aTopicList );
CleanupStack::PopAndDestroy(); // outstream
// Free the reserved space
if ( aDeleting )
{
CleanupStack::PopAndDestroy(); // disk space
sharedData.Close();
}
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::UpdateTopicL
// Updates the information for a topic already existing
// in the database.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::UpdateTopicL(
TCbsDbTopicNumber aTopicNumber,
TCbsDbTopic& aTopic )
{
// Check that the new topic number is unique.
TBool needToChangePosition( ETrue );
// Try to find the topic and leave if it was not found.
TInt oldPosition( TopicIndexInList( aTopicNumber ) );
User::LeaveIfError( oldPosition );
// Check if we have to change the position of the topic in the
// internal array
if ( aTopic.iNumber == aTopicNumber )
{
needToChangePosition = EFalse;
}
else
{
TInt topicWithTheNewNumber( TopicIndexInList( aTopic.iNumber ) );
if ( topicWithTheNewNumber != KErrNotFound &&
topicWithTheNewNumber != oldPosition )
{
User::Leave( KErrAlreadyExists );
}
}
// Write data to store.
// Deviation from EPOC standards: DoUpdateTopicL does NOT commit
// the store.
TRAPD( result, DoUpdateTopicL( aTopic, needToChangePosition,
oldPosition, EFalse ) );
// Commit both topic and unsaved msgs store
if ( result == KErrNone )
{
TRAP( result, CommitFilesL() );
}
// If either DoUpdateTopicL or CommitFilesL fails => revert.
if ( result != KErrNone )
{
TopicStoreL()->Revert();
ReloadRootStreamL();
User::Leave( result );
}
else
{
// Notify the observers.
NotifyTopicModifiedL( aTopicNumber );
}
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::CheckTopicNumber
// Checks if a topic number is valid.
// The valid topic number range in this implementation is
// 000..999, with 000 indicating an index message.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TBool CCbsDbImpTopicList::CheckTopicNumber(
TCbsDbTopicNumber aNumber ) const
{
// Check that the number is in proper range
return aNumber <= KCbsMaxValidTopicNumber;
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::WriteRootStreamL
// Write the root stream.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::WriteRootStreamL(
RWriteStream& aOut ) const
{
// Write the total amount of topic lists
TInt topicListCount( iTopicLists->Count() );
aOut.WriteInt16L( topicListCount );
// Write space for topic list stream ids
TInt index;
for ( index = 0; index < topicListCount; index++ )
{
aOut << iTopicLists->At( index ).iTopicListId;
}
// Write null stream ids
for ( ; index < KCbsRootItemsSize; index++ )
{
aOut << TStreamId( 0 );
}
aOut.CommitL();
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::WriteTopicListStreamL
// Writes topic list information to specified stream.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::WriteTopicListStreamL(
RWriteStream& aOut,
TCbsDbImpTopicList& aTopicList ) const
{
// Write the values to this topic list's stream
// Topic List name
aOut << aTopicList.iTopicListName;
// Is this the default list
CbsStreamHelper::WriteBoolL( aOut, aTopicList.iIsDefaultTopicList );
// Topic List number
aOut.WriteInt16L( aTopicList.iNumber );
// NUmber of topics in this list
aOut.WriteInt16L( iTopics->Count() );
// Write the stream IDs of the topics belonging to this list
TInt i;
for ( i = 0; i < iTopics->Count(); i++ )
{
aOut << iTopics->At( i ).iTopicId;
}
// Write space for the rest topic stream IDs
for ( ; i < KCbsDbTopicArraySize; i++ )
{
aOut << TStreamId( 0 );
}
aOut.CommitL();
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::NotifyTopicListInitializedL
// Notifies each observer that the topic list has been initialized.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::NotifyTopicListInitializedL()
{
// Notify each observer.
TInt count( iObservers->Count() );
for( TInt index( 0 ); index < count; index++ )
{
iObservers->At( index )->TopicListInitializedIndL();
}
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::NotifyTopicAddedL
// Notifies each observer that a topic has been added.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::NotifyTopicAddedL(
TCbsDbTopicNumber aNumber )
{
// Notify each observer.
TInt count( iObservers->Count() );
for ( TInt index( 0 ); index < count; index++ )
{
iObservers->At( index )->TopicAddedIndL( aNumber );
}
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::NotifyTopicModifiedL
// Notifies each observer that a topic has been modified.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::NotifyTopicModifiedL(
TCbsDbTopicNumber aNumber )
{
// Notify each observer.
TInt count( iObservers->Count() );
for( TInt index( 0 ); index < count; index++ )
{
iObservers->At( index )->TopicModifiedIndL( aNumber );
}
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::NotifyTopicDeletedL
// Notifies each observer that a topic has been deleted.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::NotifyTopicDeletedL(
TCbsDbTopicNumber aNumber )
{
// Notify each observer.
TInt count( iObservers->Count() );
for( TInt index( 0 ); index < count; index++ )
{
iObservers->At( index )->TopicDeletedIndL( aNumber );
}
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::SetHotmarkedMessage
// Sets the hotmarked message handle.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::SetHotmarkedMessage(
const TCbsDbMessageHandle& aMessageHandle )
{
// Set the hotmarked message.
iIsHotmarkedMessage = ETrue;
iMessageHandle = aMessageHandle;
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::CreateDefaultRootStreamL
// Creates a root stream and writes default values into it.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TStreamId CCbsDbImpTopicList::CreateDefaultRootStreamL(
CStreamStore& aStore ) const
{
// Create the stream
RStoreWriteStream outstream;
TStreamId id( outstream.CreateLC( aStore ) ); // on CS
// Write the amount of topic lists
outstream.WriteInt16L( 0 );
// Write space for topic list stream ids
for ( TInt index( 0 ); index < KCbsRootItemsSize; index++ )
{
outstream << TStreamId( 0 );
}
outstream.CommitL();
CleanupStack::PopAndDestroy(); // aStore
// Return the stream id.
return id;
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::WriteTopicInformationL
// Writes topic data into a stream.
// This includes number of saved messages,
// number of unread messages, topic handle,
// topic name, topic number, protection status,
// subscription status and hotmark status.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::WriteTopicInformationL(
RWriteStream& aOut,
const TCbsDbTopic& aTopic,
const TStreamId& aTopicMessagesId ) const
{
// Write saved messages.
aOut.WriteInt16L( aTopic.iSavedMessages );
// Write name.
aOut << aTopic.iName;
// Write topic number (message identifier)
aOut.WriteInt16L( aTopic.iNumber );
// Write statuses
CbsStreamHelper::WriteBoolL( aOut, aTopic.iProtected ); // Protected
CbsStreamHelper::WriteBoolL( aOut, aTopic.iSubscribed ); // Subscribed
CbsStreamHelper::WriteBoolL( aOut, aTopic.iHotmarked ); // Hotmarked
// Write unread messages count
aOut.WriteInt16L( aTopic.iUnreadMessages );
// And then write the topic messages stream id.
aOut << aTopicMessagesId;
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::RevertFilesL
// Reverts all changes made to three datafiles handled by this class.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::RevertFilesL()
{
// Check for file lock
CheckFileLockL();
iTopicStore->Revert();
iUnsavedMessageStore->Revert();
ReloadRootStreamL();
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::CommitFilesL
// Commits all changes made to two datafiles handled by this class.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::CommitFilesL()
{
TopicStoreL()->CommitL();
TInt errorCode( iUnsavedMessageStore->Commit() );
// If committing of the unsaved msg store fails, remove all
// messages in the store and rebuild the topic list
if ( errorCode != KErrNone )
{
TRAPD( errorCode2, RebuildUnsavedMessageStoreL() );
if ( errorCode2 != KErrNone )
{
CActiveScheduler::Stop();
User::Leave( KErrServerTerminated );
}
// Tell the caller that something went wrong
User::Leave( errorCode );
}
// Check if we should compact
TTime now;
TTimeIntervalMinutes interval;
now.UniversalTime();
now.MinutesFrom( iPreviousCompact, interval );
if ( interval.Int() >= KMinimumCompactInterval )
{
TopicStoreL()->CompactL();
iUnsavedMessageStore->CompactL();
iPreviousCompact = now;
}
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::RebuildUnsavedMessageStoreL
// Deletes the unsaved messages' store and rebuilds it.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::RebuildUnsavedMessageStoreL()
{
// Close the stores and delete the unsaved store
delete iUnsavedMessageStore; iUnsavedMessageStore = NULL;
delete iTopicStore; iTopicStore = NULL;
CbsUtils::DeleteFileL( iFs, *iUnsavedMessagesFilename );
// Re-create the store
DoCreateStoreL( *iUnsavedMessagesFilename );
TryToOpenFilesL( ETrue, EFalse );
// Remove the stream ids to unsaved messages, because
// they were all just deleted.
HandleDeletionOfUnsavedMessagesFileL();
// Compact the topic list
TopicStoreL()->CommitL();
TopicStoreL()->CompactL();
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::RebuildTopicAndUnsavedStoresL
// Deletes and rebuilds topic/topic list and unsaved message stores.
// Loads Standard Topic List into memory.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::RebuildTopicAndUnsavedStoresL()
{
__TEST_INVARIANT;
// Check for file lock
CheckFileLockL();
// About to write to FFS: make critical level check
CbsUtils::FFSCriticalLevelCheckL( KTopicListRootStreamSize +
KDefaultTopicListSize * 2, iFs );
if ( iMessages != NULL && iMessages->IsLockedMessages() )
{
User::Leave( KErrAccessDenied );
}
delete iTopicStore;
iTopicStore = NULL;
delete iUnsavedMessageStore;
iUnsavedMessageStore = NULL;
CbsUtils::DeleteFileL( iFs, *iTopicsFilename );
CbsUtils::DeleteFileL( iFs, *iUnsavedMessagesFilename );
// Create new files.
OpenFilesL( ETrue, EFalse );
// Add standard index topic.
AddIndexTopicL();
// Load the Standard Topic list
LoadDefaultTopicStreamL();
iIsHotmarkedMessage = EFalse;
iLastTopicNumber = 0;
iMessageHandle = 0;
// Inform the message manager.
if ( iMessages )
{
iMessages->InvalidateCache();
}
// Notify everyone.
NotifyTopicListInitializedL();
__TEST_INVARIANT;
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::GetLatestTopicNumber
// Returns the number of the topic that was added last
// to the database by topic detection feature.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CCbsDbImpTopicList::GetLatestTopicNumber(
TCbsTopicNumber& aNumber ) const
{
TInt result( KErrNone );
if ( iLastTopicNumber == 0 )
{
result = KErrNotFound;
}
aNumber = iLastTopicNumber;
return result;
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::OpenFilesL
// After a call to this function, the file stores can be assumed
// to be open and initialized.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::OpenFilesL(
TBool aDeleteExistingFiles,
TBool aCreateNewTopicList )
{
__ASSERT_DEBUG( iTopicsFilename->Length() > 0,
CbsServerPanic( ECbsInvalidFilenameDescriptor ) );
__ASSERT_DEBUG( iUnsavedMessagesFilename->Length() > 0,
CbsServerPanic( ECbsInvalidFilenameDescriptor ) );
// if LFS, delete files, create files, open files, write root stream
// if not LFS, create file if it doesn't exist, open files
// Close file stores.
delete iTopicStore;
iTopicStore = NULL;
delete iUnsavedMessageStore;
iUnsavedMessageStore = NULL;
// If any of files doesn't exist, create the file. Also writes the root
// stream of the topic file, if necessary.
// It is possible that this operation fails because FFS is full.
// In this case the server will take a break and retry. If the second
// attempt fails, the server is shut down.
TBool unsavedMsgFileExists( EFalse );
TRAPD( result, CreateFilesIfNecessaryL( unsavedMsgFileExists ) );
if ( result != KErrNone )
{
// Critical exception: wait for a while and retry.
User::After( KWaitAfterCriticalStoreException );
TBool ignoreThis( EFalse ); // value of unsavedMsgFileExists preserved
TRAP( result, CreateFilesIfNecessaryL( ignoreThis ) );
if ( result != KErrNone )
{
__DEBUGGER();
// Recovery is not possible: shut the server down.
CActiveScheduler::Stop();
User::Leave( KErrServerTerminated );
}
}
// Open the files for use. Also reads the topic file root stream.
TryToOpenFilesL( unsavedMsgFileExists == EFalse &&
aDeleteExistingFiles == EFalse,
aCreateNewTopicList );
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::CreateFilesIfNecessaryL
// Creates CBS files, if appropriate.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::CreateFilesIfNecessaryL(
TBool& aUnsavedMsgFileExisted )
{
if ( CbsUtils::ExistsL( iFs, *iTopicsFilename ) == EFalse )
{
CbsUtils::FFSCriticalLevelCheckL( KTopicListRootStreamSize +
KDefaultTopicListSize * 2, iFs );
CPermanentFileStore* store = CPermanentFileStore::CreateLC( iFs,
*iTopicsFilename, EFileWrite ); // on CS
store->SetTypeL( store->Layout() );
TStreamId id( CreateDefaultRootStreamL( *store ) );
store->SetRootL( id );
store->CommitL();
CleanupStack::PopAndDestroy(); // store
}
aUnsavedMsgFileExisted = CbsUtils::ExistsL( iFs,
*iUnsavedMessagesFilename );
if ( aUnsavedMsgFileExisted == EFalse )
{
// No critical level check, because unsaved msgs reside on ramdisk
DoCreateStoreL( *iUnsavedMessagesFilename );
}
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::DoCreateStoreL
// Creates an empty file store with the given filename.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::DoCreateStoreL(
const TDesC& aFilename )
{
CFileStore* store = CPermanentFileStore::CreateLC( iFs,
aFilename, EFileWrite ); // on CS
store->SetTypeL( store->Layout() );
store->CommitL();
CleanupStack::PopAndDestroy();
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::TryToOpenFilesL
// Tries to open topic and unsaved messages files.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::TryToOpenFilesL(
TBool aDeleteUnsavedMsgStreamIds,
TBool aCreateNewTopicList )
{
CBSLOGSTRING("CBSSERVER: >>> CCbsDbImpTopicList::TryToOpenFilesL()" );
if ( !iTopicStore )
{
CBSLOGSTRING("CBSSERVER: CCbsDbImpTopicList::TryToOpenFilesL(): *** NO iTopicStore (1) ***" );
}
// Try to open the store
TRAPD( error, iTopicStore = CFileStore::OpenL( iFs, *iTopicsFilename, EFileRead | EFileWrite ) );
CBSLOGSTRING2("CBSSERVER: CCbsDbImpTopicList::TryToOpenFilesL(); iTopicStore OpenL() error: %d", error );
TRAPD( error2, iUnsavedMessageStore = CFileStore::OpenL( iFs, *iUnsavedMessagesFilename, EFileRead | EFileWrite ) );
CBSLOGSTRING2("CBSSERVER: CCbsDbImpTopicList::TryToOpenFilesL(); iUnsavedMessageStore OpenL() error: %d", error2 );
if ( error || error2 )
{
CBSLOGSTRING("CBSSERVER: CCbsDbImpTopicList::TryToOpenFilesL(): Calling InitializeListL( ETrue )..." );
InitializeListL( ETrue );
CBSLOGSTRING("CBSSERVER: CCbsDbImpTopicList::TryToOpenFilesL(): Calling InitializeListL( ETrue ) finished." );
}
else
{
if ( iTopicLists->Count() == 0 &&
aDeleteUnsavedMsgStreamIds &&
aCreateNewTopicList )
{
// Create first topic list, since it was deleted with the file
CreateStandardTopicListL();
}
// Load the root stream for topic store.
LoadRootStreamL();
if ( aDeleteUnsavedMsgStreamIds )
{
// Load the topics and repair the topic file
// since unsaved msg file has been deleted
LoadDefaultTopicStreamL();
HandleDeletionOfUnsavedMessagesFileL();
}
}
CBSLOGSTRING("CBSSERVER: <<< CCbsDbImpTopicList::TryToOpenFilesL()" );
}
// ---------------------------------------------------------
// CCbsDbImpTopicList::ReadIndexTopicNameLC()
// Reads the localized index topic name
// (other items were commented in a header).
// ---------------------------------------------------------
HBufC* CCbsDbImpTopicList::ReadIndexTopicNameLC()
{
// Open localized resource file.
RResourceFile resourceFile;
CbsUtils::FindAndOpenDefaultResourceFileLC( iFs, resourceFile ); // on CS
// Read "Index"-string.
TResourceReader reader;
reader.SetBuffer( resourceFile.AllocReadLC( R_TEXT_INDEX_TOPIC ) );//on CS
HBufC* text = reader.ReadHBufCL();
CleanupStack::PopAndDestroy(2); // readerBuf, resourceFile
CleanupStack::PushL( text );
return text;
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::AddIndexTopicL
// Adds index topic to topic list.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::AddIndexTopicL()
{
// Open localized resource file.
HBufC* text = ReadIndexTopicNameLC();
TCbsDbTopic topic;
topic.iName.Copy( *text );
topic.iNumber = 0;
topic.iHotmarked = EFalse;
topic.iProtected = ETrue;
topic.iSubscribed = ETrue;
topic.iSavedMessages = 0;
topic.iUnreadMessages = 0;
// Add the topic without notifying anybody.
TRAPD( error, DoAddTopicL( topic ) );
if ( error != KErrNone )
{
RevertFilesL();
__TEST_INVARIANT;
User::Leave( error );
}
CleanupStack::PopAndDestroy(); // text
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::HandleDeletionOfUnsavedMessagesFileL
// Called to repair the database when Unsaved messages -file
// has been deleted, but Topics-file still contains information
// on unsaved messages.
//
// Things to do here:
// - Reset unread message counters, because a saved message
// is always also read.
// - Remove stream ids to unsaved messages from
// Topic messages -streams.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::HandleDeletionOfUnsavedMessagesFileL()
{
TRAPD( result, DoHandleDeletionOfUnsavedMessagesFileL() );
if ( result != KErrNone )
{
// Recovery impossible -> reset the database.
// Note that this function is not called when the database
// is initialized.
RebuildTopicAndUnsavedStoresL();
}
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::DoHandleDeletionOfUnsavedMessagesFileL
// Does the work for HandleDeletionOfUnsavedMessagesFileL().
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::DoHandleDeletionOfUnsavedMessagesFileL()
{
// Reset the unread counter of each topic and delete stream ids of
// unsaved messages.
TInt numberOfTopics( iTopics->Count() );
for ( TInt i( 0 ); i < numberOfTopics; i++ )
{
TCbsDbTopic topic;
FindTopicByNumberL( iTopics->At( i ).iTopicData.iNumber, topic );
topic.iUnreadMessages = 0;
DoUpdateTopicL( topic, EFalse, i, EFalse );
DeleteUnsavedMessageStreamIdsL( iTopics->At( i ).iTopicMessagesId );
}
UpdateTopicListStreamL( iCurrentTopicList, ETrue );
TopicStoreL()->CommitL();
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::DeleteUnsavedMessageStreamIdsL
// This function is called when the unsaved messages file has
// been deleted but the Topic messages -stream still contains
// stream ids to deleted message streams.
// All stream ids found in the given topic messages -stream
// pointing to the unsaved messages file are removed.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::DeleteUnsavedMessageStreamIdsL(
const TStreamId& aMsgStreamId ) const
{
CArrayFixFlat< TStreamId >* streamIds =
new ( ELeave ) CArrayFixFlat< TStreamId >( KTypicalNumberOfTopicMessages );
CleanupStack::PushL( streamIds );
RStoreReadStream instream;
instream.OpenLC( *TopicStoreL(), aMsgStreamId ); // on CS
// Read msg count
TInt numberOfMsgs( instream.ReadInt16L() );
// Read max msg count
TInt maxNumberOfMsgs( instream.ReadInt16L() );
TInt index( 0 );
for ( ; index < numberOfMsgs; index++ )
{
TBool saved( CbsStreamHelper::ReadBoolL( instream ) );
TStreamId id( 0 );
instream >> id;
if ( saved )
{
streamIds->AppendL( id );
}
}
CleanupStack::PopAndDestroy(); // instream
// Write stream ids of saved messages into the new topic message stream
// which replaces the stream identified with aMsgStreamId.
RStoreWriteStream outstream;
outstream.ReplaceLC( *TopicStoreL(), aMsgStreamId ); // on CS
TInt numberOfSavedmessages( streamIds->Count() );
// Number of messages = number of saved messages
outstream.WriteInt16L( numberOfSavedmessages );
// Number of saved messages <= number of messages <= maxNumberOfMsgs
outstream.WriteInt16L( maxNumberOfMsgs );
for ( index = 0; index < numberOfSavedmessages; index++ )
{
// All messages are saved (i.e., permanent)
CbsStreamHelper::WriteBoolL( outstream, ETrue );
outstream << streamIds->At( index );
}
for ( ; index < maxNumberOfMsgs; index ++ )
{
CbsStreamHelper::WriteBoolL( outstream, EFalse );
outstream << TStreamId( 0 );
}
outstream.CommitL();
CleanupStack::PopAndDestroy(2); // outstream, streamIds
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::UpdateTopicCountersL
// Resolves the topic position in topic list and uses this information
// to call DoUpdateTopicL.
// Changes to stores are NOT commited.
// Call to DoUpdateTopicL is not trapped.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::UpdateTopicCountersL(
const TCbsDbTopic& aTopic,
const TBool aDeleting )
{
CBSLOGSTRING("CBSSERVER: >>> CCbsDbImpTopicList::UpdateTopicCountersL()");
// Find out the position of the topic in topic list.
TInt index( TopicIndexInList( aTopic.iNumber ) );
if ( index == KErrNotFound )
{
User::Leave( KErrNotFound );
}
// DoUpdateTopicL leaves changes uncommited. EFalse for not having to
// change topic position in topic list.
DoUpdateTopicL( aTopic, EFalse, index, aDeleting );
CBSLOGSTRING("CBSSERVER: <<< CCbsDbImpTopicList::UpdateTopicCountersL()");
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::CreateStandardTopicListL
// Creates the Standard topic list (topic list no. 0)
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::CreateStandardTopicListL()
{
// Read standard topic list name from the resource file
RResourceFile resourceFile;
CbsUtils::FindAndOpenDefaultResourceFileLC( iFs, resourceFile ); // on CS
TResourceReader reader;
reader.SetBuffer( resourceFile.AllocReadLC( R_TEXT_STANDARD_TOPIC_LIST ) ); // on CS
HBufC* standardTopicListName = reader.ReadHBufCL();
CleanupStack::PushL( standardTopicListName );
// Create a new topic list
CreateNewTopicListL( standardTopicListName->Des() );
CleanupStack::PopAndDestroy( 3 ); // resourceFile, reader, standardTopicListName
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::LoadTopicsIdsL
// Reads topic IDs of a topic list from the stream.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::LoadTopicsIdsL(
const TStreamId& aTopicListStreamId )
{
// Open the topic list stream
RStoreReadStream instream;
instream.OpenLC( *TopicStoreL(), aTopicListStreamId ); // on CS
// Skip topic list name
delete HBufC::NewL( instream, KCbsDbTopicNameLength );
// Skip default list status
CbsStreamHelper::ReadBoolL( instream );
// Skip Topic List number
instream.ReadInt16L();
// Skip the amount of topics
TInt topicCount = instream.ReadInt16L();
// Clear the array
iTopicIds->ResizeL( 0 );
TStreamId id( 0 );
// Load the topic IDs
for ( TInt i = 0; i < topicCount; i++ )
{
instream >> id;
iTopicIds->AppendL( id );
}
CleanupStack::PopAndDestroy(); // instream
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::LoadTopicsL
// Loads topics of a specified topic list.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::LoadTopicsL(
const TStreamId& aTopicListStreamId )
{
// Open the topic list stream
RStoreReadStream instream;
instream.OpenLC( *TopicStoreL(), aTopicListStreamId ); // on CS
// Skip topic list name
delete HBufC::NewL( instream, KCbsDbTopicNameLength );
// Skip default list status
CbsStreamHelper::ReadBoolL( instream );
// Skip Topic List number
instream.ReadInt16L();
// Skip the amount of topics
TInt topicCount = instream.ReadInt16L();
// Clear the arrays
iTopics->ResizeL( 0 );
iTopicIds->ResizeL( 0 );
TStreamId id( 0 );
// Load the topic IDs
TInt i;
for ( i = 0; i < topicCount; i++ )
{
instream >> id;
iTopicIds->AppendL( id );
}
CleanupStack::PopAndDestroy(); // instream
// Load necessary information for each topic
TInt count = iTopicIds->Count();
TCbsDbImpTopic topic;
for ( i = 0; i < count; i++ )
{
ReadTopicInformationL( iTopicIds->At( i ), topic );
if ( topic.iTopicData.iNumber == KIndexTopicNumber )
{
HBufC* indexName = ReadIndexTopicNameLC(); // on CS
topic.iTopicData.iName.Copy( *indexName );
CleanupStack::PopAndDestroy(); // indexName
}
iTopics->AppendL( topic );
}
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::UpdateTopicStreamIdsL
// Updates the topic stream IDs.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::UpdateTopicStreamIdsL(
const TCbsDbTopicNumber aTopicNumber )
{
// Try to find the topic from current topic list
TInt position( TopicIndexInList( aTopicNumber ) );
if ( position >= 0 )
{
// Remove from the internal cache of this topic list
iTopics->Delete( position );
iCurrentTopicList.iTopicCount--;
// Update the stream
UpdateTopicListStreamL( iCurrentTopicList, EFalse );
CommitFilesL();
}
}
// -----------------------------------------------------------------------------
// CCbsDbImpTopicList::__DbgTestInvariant
// Checks that the object is in a valid state, and panics if it is not.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsDbImpTopicList::__DbgTestInvariant() const
{
/*
#if defined(_DEBUG)
#endif
*/
}
// ========================== OTHER EXPORTED FUNCTIONS =========================
// End of File