/*

* 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 "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 );