/*

* 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 module contains the implementation of CCbsDbImpTopicMessages class 

*                member functions. 

*

*/

// INCLUDE FILES

#include <e32svr.h>

#include <shareddataclient.h>

#include "CbsServerPanic.h"

#include "CbsStreamHelper.h"

#include "CbsUtils.h"

#include "CbsDbConstants.h"

#include "CCbsDbImpTopicList.h"

#include "CCbsDbImpTopicMessages.h"

#include "CCbsRecEtel.h"

#include "CCbsReceiverHelper.h"

#include "CbsLogger.h"

// CONSTANTS

// Expected maximum number of locked messages at once. 

const TInt KDefaultSpaceForLockedMessages = 1;

// CB message header size in bytes.

const TInt KCbMessageHeaderSize = 16;

// The space used for the header of messages stream

const TInt KMessageRootStreamSize = 6;

/// The space used by one message in the messages stream

const TInt KMessageEntrySize = 3;

// Default space reserved for topic messages in message stream

const TInt KDefaultSpaceForMessages = 6;

// Space for reading messages

const TInt KReadMessageSize = 92;

// ================= MEMBER FUNCTIONS =======================

// -----------------------------------------------------------------------------

// CCbsDbImpTopicMessages::CCbsDbImpTopicMessages

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

CCbsDbImpTopicMessages::CCbsDbImpTopicMessages( 

    CCbsDbImpTopicList& aTopicList, 

    RFs& aFs )

    :iTopicList( aTopicList ), 

    iCacheValid( EFalse ), 

    iCachedTopicNumber( 0 ), 

    iFs( aFs )

    {

    }

// -----------------------------------------------------------------------------

// CCbsDbImpTopicMessages::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CCbsDbImpTopicMessages::ConstructL()

    {

    // Allocate the default size for the message list.

    iMessageList = 

        new ( ELeave ) CArrayFixFlat< TCbsDbImpTopicMessagesCacheItem > 

            ( KCbsDbMaxReceivedMessages + KCbsDbMaxSavedMessages );

    // Allocate the array for locked messages.

    iLockedMessages = new ( ELeave ) CArrayFixFlat< TCbsDbMessageHandle >

        ( KDefaultSpaceForLockedMessages );

    }

// -----------------------------------------------------------------------------

// CCbsDbImpTopicMessages::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CCbsDbImpTopicMessages* CCbsDbImpTopicMessages::NewL( 

    CCbsDbImpTopicList& aTopicList, RFs& aFs )

    {

    CCbsDbImpTopicMessages* self = 

        new ( ELeave ) CCbsDbImpTopicMessages( aTopicList, aFs );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// Destructor

CCbsDbImpTopicMessages::~CCbsDbImpTopicMessages()

    {

    CBSLOGSTRING("CBSSERVER: >>> CCbsDbImpTopicMessages::~CCbsDbImpTopicMessages()");

    // Invalidate cache.

    InvalidateCache();

    // And then delete the message list.

    delete iMessageList;

    // Delete locked messages.

    delete iLockedMessages; 

    CBSLOGSTRING("CBSSERVER: <<< CCbsDbImpTopicMessages::~CCbsDbImpTopicMessages()");   

    }

// -----------------------------------------------------------------------------

// CCbsDbImpTopicMessages::InvalidateCache

// Resets the cache to default values.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CCbsDbImpTopicMessages::InvalidateCache()

    {    

    // Initialize members back to default.

    iCacheValid = EFalse;

    iCachedTopicNumber = 0;

    // Resize the message list. After the call is made, the

    // array is empty.

    if ( iMessageList )

        {

        iMessageList->Reset();

        }

    }

// -----------------------------------------------------------------------------

// CCbsDbImpTopicMessages::InvalidateCacheIfTopic

// Resets the cache to default values.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CCbsDbImpTopicMessages::InvalidateCacheIfTopic( 

    const TCbsDbTopicNumber& aNumber )

    {

    // Check the handle and then invalidate

    if ( iCachedTopicNumber == aNumber )

        {

        InvalidateCache();

        }

    }

// -----------------------------------------------------------------------------

// CCbsDbImpTopicMessages::CreateDefaultTopicMessagesStreamL

// Creates a default topic messages stream.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TStreamId CCbsDbImpTopicMessages::CreateDefaultTopicMessagesStreamL(

    CStreamStore& aStore )

    {

    // Create the stream.

    RStoreWriteStream outstream;

    TStreamId id = outstream.CreateLC( aStore ); // on CS

    // Write total amount of messages.

    outstream.WriteInt16L( 0 );

    // Write total amount of space for messages.

    outstream.WriteInt16L( KDefaultSpaceForMessages );

    for ( TInt index( 0 ); index < KDefaultSpaceForMessages; index++ )

        {

        // "Saved"-flag

        CbsStreamHelper::WriteBoolL( outstream, EFalse );

        // Write message stream id.

        outstream << TStreamId( 0 );

        }

    outstream.CommitL();

    CleanupStack::PopAndDestroy();  // outstream

    return id;

    }

// -----------------------------------------------------------------------------

// CCbsDbImpTopicMessages::CreateDefaultTopicMessagesStreamL

// Delete all topics messages.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CCbsDbImpTopicMessages::DeleteAllTopicMessagesL( 

    CStreamStore& aSavedStore,

    CStreamStore& aUnsavedStore,

    RReadStream& aIn )

    {

    // Read total amount of messages.

    TInt total( aIn.ReadInt16L() );

    // Skip space for messages.

    aIn.ReadInt16L();

    // Now, delete all streams..

    for ( TInt index( 0 ); index < total; index++ )

        {

        TBool isSaved( CbsStreamHelper::ReadBoolL( aIn ) );

        TStreamId id;

        // Read stream id.

        aIn >> id;

        CStreamStore& store = isSaved ? aSavedStore : aUnsavedStore;

        store.DeleteL( id );

        }

    }

// -----------------------------------------------------------------------------

// CCbsDbImpTopicMessages::IsLockedMessagesInTopic

// Determines whether or not there are any locked messages in 

// the topic.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TBool CCbsDbImpTopicMessages::IsLockedMessagesInTopic( 

    const TCbsDbTopicNumber& aNumber ) const

    {

    TBool result( EFalse );

    // Checks whether or not there is a locked message in the topic.

    TInt count( iLockedMessages->Count() );

    for ( TInt index( 0 ); index < count; index++ )

        {

        if ( iTopicList.ExtractTopicNumber( 

            iLockedMessages->At( index ) ) == aNumber )

            {

            result = ETrue;

            }

        }    

    return result;

    }

// -----------------------------------------------------------------------------

// CCbsDbImpTopicMessages::IsLockedMessages

// Determines whether there is at least one locked message.

// Returns ETrue, if there are any locked messages in the 

// database.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TBool CCbsDbImpTopicMessages::IsLockedMessages() const

    {

    return ( iLockedMessages->Count() > 0 );

    }

// -----------------------------------------------------------------------------

// CCbsDbImpTopicMessages::GetMessageCountL

// Returns the total amount of messages the topic contains.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CCbsDbImpTopicMessages::GetMessageCountL( 

    const TCbsDbTopicNumber& aNumber, 

    TInt& aCount )

    {

    // Load cache.

    LoadCacheL( aNumber );

    // and then get the message count.

    aCount = iMessageList->Count();

    }

// -----------------------------------------------------------------------------

// CCbsDbImpTopicMessages::GetMessageL

// Returns message information.

// Returns the message matching the given

// index value. Leaves if the index is not valid.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CCbsDbImpTopicMessages::GetMessageL( 

    const TCbsDbTopicNumber& aNumber, 

    TInt aIndex, 

    TCbsDbMessage& aMessage )

    {

    // Load the cache.

    LoadCacheL( aNumber );

    // Check if the index is not valid.

    if ( ( aIndex < 0 ) || ( aIndex >= iMessageList->Count() ) )

        {

        User::Leave( KErrNotFound );

        }

    // Load the message.

    LoadMessageL( aIndex, aMessage );

    }

// -----------------------------------------------------------------------------

// CCbsDbImpTopicMessages::FindMessageByHandleL

// Finds the message for given handle and returns it.

// Returns the message matching the given

// index value.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CCbsDbImpTopicMessages::FindMessageByHandleL( 

    const TCbsDbMessageHandle& aHandle, 

    TCbsDbMessage& aMessage )

    {

    // Load cache

    LoadCacheL( iTopicList.ExtractTopicNumber( aHandle ) );

    // Load message

    LoadMessageL( FindMessagePositionByHandleL( aHandle ), aMessage );

    }

// -----------------------------------------------------------------------------

// CCbsDbImpTopicMessages::GetMessageContentsL

// Returns the contents of a message.

// Stores the contents of the message to the buffer aContents. 

// If aContents is too small to contain the whole message

// body, the message body is truncated.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CCbsDbImpTopicMessages::GetMessageContentsL( 

    const TCbsDbMessageHandle& aHandle, 

    TPtr& aContents,

    TUint aSize )

    {

    LoadCacheL( iTopicList.ExtractTopicNumber( aHandle ) );

    TInt position( FindMessagePositionByHandleL( aHandle ) );

    TCbsDbMessage message;

    LoadMessageL( position, message );

    LoadMessageContentsL( iMessageList->At( position ).iContentsId, 

                          aContents, message.iPermanent, aSize );

    }

// -----------------------------------------------------------------------------

// CCbsDbImpTopicMessages::DeleteMessageL

// Deletes a message. Leaves if the message is protected

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CCbsDbImpTopicMessages::DeleteMessageL( 

    const TCbsDbMessageHandle& aHandle,

    const CCbsRecEtel& aReceiver )

    {

    // Get the topic handle.

    LoadCacheL( iTopicList.ExtractTopicNumber( aHandle ) );

    // Check if the message is locked.

    if ( IsMessageLocked( aHandle ) )

        {

        // Yes, leave.

        User::Leave( KErrAccessDenied );

        }

    else

        {

        // Otherwise, delete.

        TRAPD( error, DoDeleteMessageL( 

            FindMessagePositionByHandleL( aHandle ) ) );

        if ( error != KErrNone )

            {

            // Failed.

            RevertFileOperationL( error );

            }

        else

            {

            // Update the soft notification dialog, if topic is hotmarked

            UpdateSoftNotificationL( aHandle, aReceiver );

            }

        }

    iTopicList.NotifyTopicModifiedL( 

        iTopicList.ExtractTopicNumber( aHandle ) );

    }

// -----------------------------------------------------------------------------

// CCbsDbImpTopicMessages::AddMessageL

// Creates a new message to the topic.

// Stores a handle to the message in aHandle.

// FFS critical level check is made prior to operation.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CCbsDbImpTopicMessages::AddMessageL( 

    const TCbsDbTopicNumber& aNumber, 

    TCbsDbMessage& aMessage, 

    const TPtrC& aContents )

    {

    CBSLOGSTRING("CBSSERVER: >>> CCbsDbImpTopicMessages::AddMessageL()");

    LoadCacheL( aNumber );

    aMessage.iLength = aContents.Length();

    CBSLOGSTRING2("CBSSERVER: CCbsDbImpTopicMessages::AddMessageL(): Content length: %d.", aMessage.iLength );

    // Generate a new message handle.

    aMessage.iHandle = GenerateNewMessageHandle( aNumber );    

    // Make sure that the message is not inserted as permanent

    aMessage.iPermanent = EFalse;

    TRAPD( error, DoAddMessageL( aMessage, aContents ) );

    if ( error != KErrNone )

        {

        CBSLOGSTRING2("CBSSERVER: CCbsDbImpTopicMessages::AddMessageL(): DoAddMessageL() failed, error: %d.", error );

        // Failed.

        RevertFileOperationL( error );

        CBSLOGSTRING("CBSSERVER: CCbsDbImpTopicMessages::AddMessageL(): RevertFileOperationL() finished OK." );

        }

    CBSLOGSTRING("CBSSERVER: <<< CCbsDbImpTopicMessages::AddMessageL()");

    }

// -----------------------------------------------------------------------------

// CCbsDbImpTopicMessages::SaveMessageL

// Saves a message. 

// This operation is called "keeping" in the UI. 

// The CBS server has a global limit for saved 

// messages. The function leaves, if this is exceeded. 

// A saved message has it's permanent-flag raised.

// FFS critical level check is made prior to the operation.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CCbsDbImpTopicMessages::SaveMessageL( 

    const TCbsDbMessageHandle& aHandle,

    const CCbsRecEtel& aReceiver )

    {

    // Load cache.

    TCbsTopicNumber topicNumber( iTopicList.ExtractTopicNumber( aHandle ) );

    LoadCacheL( topicNumber );

    // Now find message by handle.

    TInt position( FindMessagePositionByHandleL( aHandle ) );

    TCbsDbMessage message;

    LoadMessageL( position, message );

    TStreamId contentsId( iMessageList->At( position ).iContentsId );

    // This function should not be called if the message is already permanent.

    if ( message.iPermanent )

        {

        User::Leave( KErrAlreadyExists );

        }

    // Check that the limit for maximum saved messages/topic is not exceeded.

    TCbsDbTopic topic;

    iTopicList.FindTopicByNumberL( topicNumber, topic );

    if ( iTopicList.TotalSavedMessages() >= KCbsDbMaxSavedMessages )

        {

        User::Leave( KErrOverflow );

        }

    // FFS critical level check (header is 16 bytes, message coded in Unicode)

    CbsUtils::FFSCriticalLevelCheckL( KCbMessageHeaderSize + 

        2 * message.iLength, iFs );

    // Create a temporary buffer for message body and load the contents into

    // the buffer.

    HBufC* buffer = HBufC::NewLC( message.iLength ); // on CS

    TPtr contentPtr( buffer->Des() );

    LoadMessageContentsL( contentsId, contentPtr, EFalse, message.iLength );

    // Delete message's previous header and body streams.

    TCbsDbImpTopicMessagesCacheItem item( iMessageList->At( position ) );    

    TRAPD( result, DoSaveMessageL( message, item, contentPtr, position ) );

    CleanupStack::PopAndDestroy( buffer );

    if ( result != KErrNone )

        {

        RevertFileOperationL( result );

        }

    else

        {

        iTopicList.NotifyTopicModifiedL( 

            iTopicList.ExtractTopicNumber( aHandle ) );

        // Update the soft notification dialog, if topic is hotmarked

        UpdateSoftNotificationL( aHandle, aReceiver );

        }

    }

// -----------------------------------------------------------------------------

// CCbsDbImpTopicMessages::DoSaveMessageL

// Saves a message.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CCbsDbImpTopicMessages::DoSaveMessageL( 

    TCbsDbMessage& aMessage,

    const TCbsDbImpTopicMessagesCacheItem& aItem,

    const TDesC& aContentPtr,

    TInt aPosition )

    {

    CFileStore* store = iTopicList.UnsavedMessagesStore();

    store->Delete( aItem.iId );

    store->Delete( aItem.iContentsId );

    TBool needToUpdateReadCounter( EFalse );

    aMessage.iPermanent = ETrue;

    if ( !aMessage.iRead ) 

        {

        needToUpdateReadCounter = ETrue;

        aMessage.iRead = ETrue;

        }

    // Create new streams for message header and body.

    TStreamId contentsStream( CreateMessageContentsStreamL( 

        *iTopicList.TopicStoreL(), aContentPtr ) );

    TStreamId messageStream( CreateMessageStreamL( 

        *iTopicList.TopicStoreL(), aMessage, contentsStream ) );