/*

* Copyright (c) 2004 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

*      Implementation of class CFavouritesSrvDb

*      

*

*/

// INCLUDE FILES

#include <s32std.h>

#include <eikenv.h>

#include <rfsApMapper.h>

#include <commdb.h>

#include "FavouritesSrvDb.h"

#include "FavouritesSrvTable.h"

#include "FavouritesItemImpl.h"

#include "FavouritesItemImplList.h"

#include "FavouritesPanic.h"

#include "FavouritesFilter.h"

#include "UidMap.h"

#include "FavouritesLogger.h" 

#include "FavouritesFolder.h"

// CONSTANTS

/// Uid list granularity.

LOCAL_D const TInt KUidListGranularity = 4;

/// Postfix list granularity.

LOCAL_D const TInt KPostfixListGranularity = 4;

/// Number of updates needed to trigger automatic compaction.

LOCAL_D const TInt KUpdatesNeededForAutoCompact = 32;

/// Length of filename: 8 char.

LOCAL_D const TInt KFnameLength = 8;

// Secure policy ID of the Faveng database files.

LOCAL_D const TUint KUidFavengDbPolicy = 0x101FD685;

// ==================== LOCAL FUNCTIONS ====================

/**

* Given aName in the format <prefix> or <prefix><integer in parenthesis>,

* return a pointer to the leading part. That is, if there is trailing

* <integer in  parenthesis>, then that is excluded; if there is no trailing

* part, then the original decriptor is returned.

* Examples:

*   - "Foo" returns "Foo";

*   - "Foo(12)" returns "Foo";

*   - "Foo(12 34)" returns "Foo(12 34)";

*

* @param aName Name to get prefix from.

* @return Pointer to prefix part.

*/

LOCAL_C TPtrC GetPrefix( const TDesC& aName )

    {

    TPtrC prefix = aName;

    TInt length = aName.Length();

    if ( length >= 3 && aName[length - 1] == ')' )

        {

        // Any name shorter than 3 chars cannot have a postfix.

        TInt openPar = aName.LocateReverse('(');

        if ( openPar != KErrNotFound )

            {

            // aName looks like "<prefix>(<something>)".

            // See if <something> is an integer number.

            TPtrC num = aName.Mid( openPar + 1, length - openPar - 2);

            TInt val;

            TLex lex( num );

            if ( lex.Val( val ) == KErrNone )

                {

                // Yes, the trailer is a parenthesized integer.

                prefix.Set( aName.Left( openPar ) );

                }

            }

        }

    return prefix;

    }

/**

* If aName is constructed from aPrefix with a positive integer postfix,

* get the numeric value of the postfix, e.g:

*   - GetPostfix( "Foo(3)", "Foo" ) == 3

* If aName is the same as aPrefix, return 0, e.g.:

*   - GetPostfix( "Foo", "Foo" ) == 0

* If aName is not constructed from aPrefix, return -1, e.g.:

*   - GetPostfix( "Foobar", "Foo" ) == -1

*   - GetPostfix( "Foo(23 45)", "Foo" ) == -1

* If postfix is 0 or negative, return -1, e.g.:

*   - GetPostfix( "Foo(00)", "Foo" ) == -1

*   - GetPostfix( "Foo(-8)", "Foo" ) == -1

*

* Return values for the following cases cannot be differentiated (-1 for all):

* - postfix is 0;

* - postfix is negative;

* - aName not constructed from aPrefix.

*

* @param aName Name to get postfix from.

* @param aPrefix Prefix to be searched.

* @return Postfix value.

*/

LOCAL_C TInt GetPostfix( const TDesC& aName, const TDesC& aPrefix )

    {

    TInt postfix = -1;

    TInt nameLength = aName.Length();

    TInt prefixLength = aPrefix.Length();

    if ( nameLength >= prefixLength && aName.FindF( aPrefix ) == 0 )

        {

        // aName is longer or equal length, and

        // aPrefix can be found in the beginning of aName.

        if ( nameLength == prefixLength )

            {

            // They have the same length; they equal.

            postfix = 0;

            }

        else if (

                nameLength - prefixLength >= 3 &&   // Because of this...

                aName[prefixLength] == '(' &&

                aName[nameLength - 1] == ')'        // ... this is safe (*)

                )

            {

            // (*) "aName[nameLength - 1]" no need to check whether this

            // index is valid. nameLength is at least 3 characters longer

            // than prefixLength (a positive integer) -> nameLength >= 3.

            // aName looks like "aPrefix(<something>)".

            // See if <something> is an integer number.

            TPtrC num = aName.Mid

                ( prefixLength + 1, nameLength - prefixLength - 2 );    // (**)

            // (**) These are also safe because nameLength - prefixLength >= 3.

            TInt val;

            TLex lex( num );

            if ( lex.Val( val ) == KErrNone && val > 0)

                {

                // Yes, the trailer is a positive integer.

                postfix = val;

                }

            }

        }

    return postfix;

    }

/**

* Generate filename for uid: return number as 8 character hex string.

* @param aUid Uid.

* @param aName Filename returned here. Minimum length KFnameLength.

*/

LOCAL_C void FilenameForUid( TInt aUid, TDes& aName )

    {

    __ASSERT_DEBUG( aName.MaxLength() >= KFnameLength, \

        FavouritesPanic( EFavouritesInternal ) );

    aName.NumFixedWidth( STATIC_CAST( TUint, aUid ), EHex, KFnameLength );

    }

/**

* Get uid for filename; reverse of FilenameForUid.

* @param aName Filename.

* @return Uid or KFavouritesNullUid.

*/

LOCAL_C TInt UidForFilename( const TDesC& aName )

    {

    // Parse the supplied text as hex number.

    TInt uid = KFavouritesNullUid;

    if ( aName.Length() == KFnameLength )

        {

        // Length is OK, check contents.

        TUint val;

        TLex lex( aName );

        if ( !lex.Val( val, EHex ) && lex.Eos() )

            {

            // OK, this filename can be parsed as hex TUint.

            uid = STATIC_CAST( TInt, val );

            }

        }

    return uid;

    }

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

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

// CBookmarkSrvDb::NewL

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

//

CFavouritesSrvDb* CFavouritesSrvDb::NewL

( RFs& aFs, RDbs& aDbs, const TDesC& aPath, const TDesC& aDBName )

    {

    CFavouritesSrvDb* db = new (ELeave) CFavouritesSrvDb( aFs, aDbs );

    CleanupStack::PushL( db );

    db->ConstructL( aPath , aDBName );

    CleanupStack::Pop();    // db

    return db;

    }

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

// CFavouritesSrvDb::~CFavouritesSrvDb

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

//

CFavouritesSrvDb::~CFavouritesSrvDb()

    {

    if ( iOpen )

        {

        if ( iInTransaction )

            {

            Rollback();

            }

        TRAP_IGNORE( DeleteOrphanedFilesL() );

        // TODO move compacting to server side, when last client exits.

        (void)iDatabase.Compact();  // Any error is silently ignored.

        iDatabase.Close();

        iOpen = EFalse;

        }

    delete iPath;   

    delete iSavedFilePath;    

    iSecureDbFormat.Close();

    }

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

// CFavouritesSrvDb::IsDamagedL

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

//

TBool CFavouritesSrvDb::IsDamagedL()

    {

    TBool damaged = EFalse;

    // We must open a table to make RDbNameDatabase::IsDamaged() work!.

    RFavouritesSrvTable table;

    table.OpenL( iDatabase );

    damaged = iDatabase.IsDamaged();

    table.Close();

    return damaged;

    }

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

// CFavouritesSrvDb::RecoverL

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

//

void CFavouritesSrvDb::RecoverL()

    {

    User::LeaveIfError( iDatabase.Recover() );

    }

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

// CFavouritesSrvDb::CompactL

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

//

void CFavouritesSrvDb::CompactL()

    {

    User::LeaveIfError( iDatabase.Compact() );

    iUpdatesSinceLastCompact = 0;

    }

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

// CFavouritesSrvDb::Size

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

//

RDbDatabase::TSize CFavouritesSrvDb::Size() const

    {

    return iDatabase.Size();

    }

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

// CFavouritesSrvDb::UpdateStatsL

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

//

void CFavouritesSrvDb::UpdateStatsL()

    {

    User::LeaveIfError( iDatabase.UpdateStats() );

    }

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

// CFavouritesSrvDb::BeginL

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

//

void CFavouritesSrvDb::BeginL( TBool aWrite /*=EFalse*/ )

    {

    __ASSERT_DEBUG( !iInTransaction, \

        FavouritesPanic( EFavouritesNestedTransaction ) );

    // Three parts: table open + transacion + (optional) write lock.

    // Temp use of cleanup items make the three atomic.

    iTable.OpenL( iDatabase );

    CleanupClosePushL<RFavouritesSrvTable>( iTable );

    User::LeaveIfError( iDatabase.Begin() );

    iInTransaction = ETrue;

    CleanupStack::PushL( TCleanupItem( StaticRollback, this ) );

    if ( aWrite )

        {

        iTable.PutWriteLockL();

        }

    CleanupStack::Pop( 2 ); // Rollback, Closing iTable

    }

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

// CFavouritesSrvDb::CommitL

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

//

void CFavouritesSrvDb::CommitL()

    {

    __ASSERT_DEBUG( iInTransaction, \

        FavouritesPanic( EFavouritesNoTransaction ) );

    User::LeaveIfError( iDatabase.Commit() );

    iInTransaction = EFalse;

    iTable.Close();

    if ( iUpdatesSinceLastCompact > KUpdatesNeededForAutoCompact )

        {

        // Auto-compact, to avoid overgrowth.

        TRAP_IGNORE( CompactL() );

        }

    }

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

// CFavouritesSrvDb::Rollback

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

//

void CFavouritesSrvDb::Rollback()

    {

    __ASSERT_DEBUG( iInTransaction, \

        FavouritesPanic( EFavouritesNoTransaction ) );

    iDatabase.Rollback();

    iInTransaction = EFalse;

    iTable.Close();

    }

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

// CFavouritesSrvDb::GetL

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

//

void CFavouritesSrvDb::GetL( TInt aUid, CFavouritesItemImpl& aItem )

    {

    TBool ownTransaction;

    BeginIfNeededL( /*aWrite=*/EFalse, ownTransaction );

    iTable.GotoToUidL( aUid );

    iTable.GetL();

    iTable.ReadItemDataL( aItem );

    CommitIfNeededL( ownTransaction );

    }

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

// CFavouritesSrvDb::GetAllL

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

//

void CFavouritesSrvDb::GetAllL

( CFavouritesItemImplList& aItemList, const TFavouritesFilter& aFilter )

    {

    TBool ownTransaction;

    BeginIfNeededL( /*aWrite=*/EFalse, ownTransaction );

    iTable.SetFiltersL( aFilter );

    CFavouritesItemImpl* item;

    iTable.BeginningL();

    while( iTable.NextL() )

        {

        item = CFavouritesItemImpl::NewLC();

        iTable.GetL();

        iTable.ReadItemDataL( *item );

        aItemList.AppendL( item );

        CleanupStack::Pop();    // item; owner is the list now.

        }

    iTable.ClearFilters();

    CommitIfNeededL( ownTransaction );

    }

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

// CFavouritesSrvDb::PreferredUidL

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

//

TInt CFavouritesSrvDb::PreferredUidL( TInt aFolder )

{

    TInt uid( KFavouritesNullUid );

    TBool ownTransaction;

    BeginIfNeededL( /*aWrite=*/EFalse, ownTransaction );

    if ( iTable.SeekToUidL( aFolder ) )

        {

        iTable.GetL();

        if ( iTable.Type() == CFavouritesItem::EFolder )

            {

            uid = iTable.PreferredUid();

            }

        }

    CommitIfNeededL( ownTransaction );

    return uid;

}

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

// CFavouritesSrvDb::GetUidsL

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

//

void CFavouritesSrvDb::GetUidsL

( CArrayFix<TInt>& aUids, const TFavouritesFilter& aFilter )

    {

    TBool ownTransaction;

    BeginIfNeededL( /*aWrite=*/EFalse, ownTransaction );

    iTable.SetFiltersL( aFilter );

    iTable.BeginningL();

    while( iTable.NextL() )

        {

        iTable.GetL();

        aUids.AppendL( iTable.Uid() );

        }

    iTable.ClearFilters();

    CommitIfNeededL( ownTransaction );

    }

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

// CFavouritesSrvDb::DeleteL

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

//

void CFavouritesSrvDb::DeleteL( TInt aUid )

    {

    if ( aUid == KFavouritesRootUid || aUid == KFavouritesHomepageUid )

        {

        // Cannot delete these.

        User::Leave( KErrAccessDenied );

        }

    // Make a list, to remember which items were deleted.

    CArrayFix<TInt>* deletedUids =

        new (ELeave) CArrayFixFlat<TInt>( KUidListGranularity );

    CleanupStack::PushL( deletedUids );

    TBool ownTransaction;

    BeginIfNeededL( /*aWrite=*/ETrue, ownTransaction );

    iTable.GotoToUidL( aUid );

    DeleteCurrentL( *deletedUids );

    CommitIfNeededL( ownTransaction );

    // Delete associated files.

    TInt i;

    TBuf<KFnameLength> name;

    TParse parse;

    for ( i = 0; i < deletedUids->Count(); i++ )

        {

        FilenameForUid( deletedUids->At( i ), name );

        User::LeaveIfError( parse.SetNoWild( name, iPath, NULL ) );

        (void)iFs.Delete( parse.FullName() );

        // Errors ignored; the file may be locked etc. etc.

        // Orphaned file cleanup will remove them eventually.

        }

    CleanupStack::PopAndDestroy();  // deletedUids

    }

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

// CFavouritesSrvDb::UpdateL

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

//

void CFavouritesSrvDb::UpdateL

( CFavouritesItemImpl& aItem, TInt aUid, TBool aAutoRename )

    {

    if ( aUid == KFavouritesRootUid ||

         aUid == KFavouritesHomepageUid ||

         aUid == KFavouritesLastVisitedUid )

        {

        // Cannot modify these.

        // (Root cannot be modified at all; the others can be modified but

        // not through this method.)

        User::Leave( KErrAccessDenied );

        }

    TBool ownTransaction;

    BeginIfNeededL( /*aWrite=*/ETrue, ownTransaction );

    iTable.GotoToUidL( aUid );

    UpdateCurrentL( aItem, aAutoRename ? EAutoRename : EDontRename );

    CommitIfNeededL( ownTransaction );

    }

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

// CFavouritesSrvDb::AddL

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

//

void CFavouritesSrvDb::AddL( CFavouritesItemImpl& aItem, TBool aAutoRename )

    {

    TBool ownTransaction;

    BeginIfNeededL( /*aWrite=*/ETrue, ownTransaction );

    DoAddL( aItem, aAutoRename ? EAutoRename : EDontRename );

    CommitIfNeededL( ownTransaction );

    }

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

// CFavouritesSrvDb::SetSpecialItemL

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

//

void CFavouritesSrvDb::SetSpecialItemL( CFavouritesItemImpl& aItem, TInt aUid )

    {

    __ASSERT_DEBUG( \

        aUid == KFavouritesHomepageUid || aUid == KFavouritesLastVisitedUid, \

        FavouritesPanic( EFavouritesInternal )

        );

    if ( aItem.ParentFolder() != KFavouritesRootUid )

        {

        // Must be in root.

        User::Leave( KErrArgument );

        }

    TBool ownTransaction;

    BeginIfNeededL( /*aWrite=*/ETrue, ownTransaction );

    if ( iTable.SeekToUidL( aUid ) )

        {

        UpdateCurrentL( aItem, ESuppressCheck );

        }

    else

        {

        DoAddL( aItem, ESuppressCheck );

        // Cursor is still on the new record. Write uid back.

        iTable.UpdateLC();

        iTable.SetUidL( aUid );

        iTable.PutL();

        aItem.SetUid( aUid );                   // Get uid back.

        aItem.SetModified( iTable.Modified() ); // Get modtime.

        }

    CommitIfNeededL( ownTransaction );

    }

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