/*

* Copyright (c) 2009 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:

*

*/

#include "afstorage.h"

#include <bautils.h>

#include <hash.h>

#include <s32mem.h>

#include "afdatabasecleaner.h"

#include "afqueries.h"

#include "afentry.h"

_LIT(KDbName, "activity.db");

_LIT(KDbDrive, "c:");

const TInt KMaxPathLength = 256;

_LIT(KNonPersistent, "non_persistent\\");

_LIT(KPersistent, "persistent\\");

_LIT(KUidFormat, "%+08x\\");

_LIT(KExtFormat, ".mbm");

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

/**

 * Constructor for performing 1st stage construction

 * @param session - initialized session to file system

 */

CAfStorage::CAfStorage(RFs& session)

:

iFsSession(session)

    {

    // No implementation required

    }

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

/**

 * Destructor.

 */

CAfStorage::~CAfStorage()

    {

    delete iDatabaseCleaner;

    iActDb.Close();

    delete iFileStore;

    }

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

/**

 * Two-phased constructor.

 * @param session - initialized session to file system

 */

CAfStorage* CAfStorage::NewL(RFs& session)

    {

    CAfStorage* self = new (ELeave) CAfStorage(session);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(); // self;

    return self;

    }

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

/**

 * EPOC default constructor for performing 2nd stage construction

 */

void CAfStorage::ConstructL()

    {

    RBuf path;

    CleanupClosePushL( path );

    path.CreateL(KMaxPathLength);

    User::LeaveIfError(iFsSession.PrivatePath(path ));

    path.Append(KDbName);

    path.Insert(0, KDbDrive);

    BaflUtils::EnsurePathExistsL(iFsSession, path);

    BaflUtils::FileExists(iFsSession, path) ? OpenDbL(path) : CreateDbL(path);

    CleanupStack::PopAndDestroy(&path);

    iDatabaseCleaner = new (ELeave) CAfDatabaseCleaner(iActDb);

    DeleteNonPersistentActivitiesL();

    RequestCleanup();

    }

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

/**

 * Create database and its structure

 * @param databaseFile - database file path

 */

void CAfStorage::CreateDbL(const TDesC& databaseFile)

    {

    iFileStore = CPermanentFileStore::ReplaceL(iFsSession,

                                               databaseFile,

                                               EFileRead|EFileWrite);

    iFileStore->SetTypeL(iFileStore->Layout());// Set file store type

    TStreamId id = iActDb.CreateL(iFileStore);// Create stream object

    iFileStore->SetRootL(id);// Keep database id as root of store

    iFileStore->CommitL();// Complete creation by commiting

    CreateTableL();

    }

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

/**

 * Open database

 * @param databaseFile - database file path

 */

void CAfStorage::OpenDbL(const TDesC& databaseFile)

    {

    TRAPD( errNo,

           iFileStore = CPermanentFileStore::OpenL( iFsSession,

                                                    databaseFile,

                                                    EFileRead|EFileWrite );

           iFileStore->SetTypeL( iFileStore->Layout() ); /* Set file store type*/

           iActDb.OpenL( iFileStore, iFileStore->Root() );

           VerifyTableL(); )

    if( KErrNone != errNo )

        {

        //database is corrupted. recreate

        iActDb.Close();

        delete iFileStore;

        iFileStore = 0;

        CreateDbL( databaseFile );

        }

    }

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

/**

 * Verify database structure

 */

void CAfStorage::VerifyDbL()

{

    TInt errNo(KErrCorrupt);

    CDbTableNames* tables = iActDb.TableNamesL();

    CleanupStack::PushL( tables );

    for( TInt iter(0); iter < tables->Count() && KErrNone != errNo; ++iter )

        {

        if( 0 == (*tables)[iter].Compare( KActivityTableName() ) )

            {

            VerifyTableL();

            errNo = KErrNone;

            }

        }

    CleanupStack::PopAndDestroy( tables );

    User::LeaveIfError( errNo );

}

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

CDbColSet* CAfStorage::ExpectedTableLC()

    {

    CDbColSet* actColSet = CDbColSet::NewLC();

    TDbCol appName(KApplicationColumnName, EDbColInt64);

    appName.iAttributes = TDbCol::ENotNull;

    actColSet->AddL( appName );

    TDbCol actName( KActivityColumnName, EDbColText16 );// Using default length

    actName.iAttributes = TDbCol::ENotNull;

    actColSet->AddL( actName );

    // custom name

    actColSet->AddL( TDbCol( KCustomNameColumnName, EDbColText16 ) );

    TDbCol actFlags( KFlagsColumnName, EDbColInt32 );

    actFlags.iAttributes = TDbCol::ENotNull;

    actColSet->AddL(actFlags);

    TDbCol actTimestamp( KTimestampColumnName, EDbColDateTime );

    actTimestamp.iAttributes = TDbCol::ENotNull;

    actColSet->AddL(actTimestamp);

    actColSet->AddL( TDbCol( KDataColumnName, EDbColLongBinary ) );// Stream Data

    return actColSet;

    }

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

/**

 * Create database structure

 */

void CAfStorage::CreateTableL()

    {

    CDbColSet* actColSet(ExpectedTableLC());

    // Create the table

    User::LeaveIfError(iActDb.CreateTable(KActivityTableName,

                                         *actColSet));

    CleanupStack::PopAndDestroy(actColSet);

    }

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

/**

 * Verify table structure

 */

void CAfStorage::VerifyTableL()

    {

    CDbColSet *currentTable(iActDb.ColSetL(KActivityTableName));

    CleanupStack::PushL(currentTable);

    CDbColSet *expectedTable(ExpectedTableLC());

    for( TInt iter(1); iter <= expectedTable->Count(); ++iter )

        {

        const TDbCol& expectedColumn((*expectedTable)[iter]);

        const TDbCol* currentColumn(currentTable->Col(expectedColumn.iName));

        if( 0 == currentColumn ||

            expectedColumn.iAttributes != currentColumn->iAttributes || 

            expectedColumn.iMaxLength != currentColumn->iMaxLength || 

            expectedColumn.iType != currentColumn->iType )

            {

            User::Leave(KErrCorrupt);

            }

        }

    CleanupStack::PopAndDestroy( expectedTable );

    CleanupStack::PopAndDestroy( currentTable );

    }

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

/**

 * Delete non-persistent activities

 */

void CAfStorage::DeleteNonPersistentActivitiesL()

    {

    HBufC *query(BuildQueryLC(KDeleteNonPersistentActivities(), 

                              CAfEntry::Persistent, 

                              KNullDesC));

    User::LeaveIfError(iActDb.Execute(*query));

    RBuf privatePath;

    CleanupClosePushL(privatePath);

    privatePath.CreateL(KMaxPathLength);

    StoragePathL(privatePath, Fs(), FALSE);

    CFileMan *fileMan = CFileMan::NewL(Fs());

    TInt i = fileMan->RmDir(privatePath);

    delete fileMan;

    CleanupStack::PopAndDestroy(&privatePath);

    CleanupStack::PopAndDestroy(query);

    }

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

/**

 * Save activity

 * @param entry - activity data

 */

void CAfStorage::SaveActivityL(CAfEntry &entry)

{

    // @todo check if this can be tidied up

    //verify if row already exists

    TInt errNo(KErrNone);

    RDbView view;

    CleanupClosePushL(view);

    TRAP(errNo, GetActivityForUpdateL(view, entry.ApplicationId(), entry.ActivityId()));

    if( KErrNone == errNo )

        {

        // update

        view.UpdateL();

        TRAPD(errNo,

        CDbColSet* colSet = view.ColSetL();

        CleanupStack::PushL(colSet);

        view.SetColL(colSet->ColNo(KFlagsColumnName), entry.Flags());

        view.SetColL(colSet->ColNo(KTimestampColumnName), entry.Timestamp());

        view.SetColL(colSet->ColNo(KCustomNameColumnName), entry.CustomActivityName());

        ExternalizeDataL(view, entry, colSet->ColNo(KDataColumnName));

        view.PutL();

        CleanupStack::PopAndDestroy(colSet);)

        if (KErrNone != errNo) 

            {

            view.Cancel();

            User::Leave(errNo);

            }

        }

    else

        {

        // insert

        //write table

        RDbTable table;

        CleanupClosePushL(table);

        User::LeaveIfError(table.Open(iActDb, KActivityTableName, table.EUpdatable));

        CDbColSet *row = table.ColSetL();

        CleanupStack::PushL(row);

        table.InsertL();

        TRAP(errNo,

        table.SetColL(row->ColNo(KApplicationColumnName), TInt64(entry.ApplicationId()));

        table.SetColL(row->ColNo(KActivityColumnName), entry.ActivityId());

        table.SetColL(row->ColNo(KCustomNameColumnName), entry.CustomActivityName());

        table.SetColL(row->ColNo(KFlagsColumnName), entry.Flags());

        table.SetColL(row->ColNo(KTimestampColumnName), entry.Timestamp());

        ExternalizeDataL(table, entry, row->ColNo(KDataColumnName));

        table.PutL();)

        if (KErrNone != errNo) {

            table.Cancel();

            User::Leave(errNo);

        }

        CleanupStack::PopAndDestroy(row);

        CleanupStack::PopAndDestroy(&table);

    }

    CleanupStack::PopAndDestroy(&view);

}

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

/**

 * Delete activity

 * @param appId - application id

 * @param actId - activity id

 */

void CAfStorage::DeleteActivityL(CAfEntry& entry)

    {

    HBufC *query(DeleteRowLC(entry.ApplicationId(), entry.ActivityId()));

    User::LeaveIfError(iActDb.Execute(*query));

    CleanupStack::PopAndDestroy(query);

    }

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

//

void CAfStorage::DeleteActivitiesL(CAfEntry& entry)

    {

    HBufC *query(DeleteRowsLC(entry.ApplicationId()));

    User::LeaveIfError(iActDb.Execute(*query));

    RBuf privatePath;

    CleanupClosePushL(privatePath);

    privatePath.CreateL(KMaxPathLength);

    AppStoragePathL(privatePath, Fs(), entry.ApplicationId(), FALSE);

    CFileMan *fileMan = CFileMan::NewL(Fs());

    CleanupStack::PushL(fileMan);

    fileMan->RmDir(privatePath);

    privatePath.Zero();

    AppStoragePathL(privatePath, Fs(), entry.ApplicationId(), TRUE);

    fileMan->RmDir(privatePath);

    CleanupStack::PopAndDestroy(fileMan);

    CleanupStack::PopAndDestroy(&privatePath);

    CleanupStack::PopAndDestroy(query);

    }

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

//

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

//

void CAfStorage::AllActivitiesL(RPointerArray<CAfEntry>& dst, TInt aLimit)

    {

    ActivitiesL(dst, KSelectRows(), CAfEntry::Public, aLimit);

    }

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

/**

 * Serialize application activity into the buffer

 * @param dst - destination buffer

 * @param appId - application id

 */

void CAfStorage::ActivitiesL(RPointerArray<CAfEntry>& dst,TInt appId)

    {

    HBufC *query(SelectRowsLC(appId));

    ActivitiesL(dst, *query, CAfEntry::Private);

    CleanupStack::PopAndDestroy(query);

    }

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

/**

 * Serialize application activity into the buffer

 * @param dst - destination entry

 * @param src - condition pattern

 */

void CAfStorage::ActivityL(RPointerArray<CAfEntry> &dst, CAfEntry& src)

    {

    HBufC *query = SelectRowLC(src.ApplicationId(), src.ActivityId());

    ActivitiesL(dst, *query, CAfEntry::Private, 1, ETrue);

    if( 0 >= dst.Count() )

        {

        User::Leave(KErrNotFound);

        }

    CleanupStack::PopAndDestroy(query);

    }

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

/**

 * Provide initialized file system session

 * @return file system session

 */

RFs& CAfStorage::Fs()

    {

    return iFsSession;

    }

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

/**

 * Format query to select activity row

 * @param appId - application id

 * @param actId - activity id

 * @return formated sql query

 */

HBufC* CAfStorage::SelectRowLC(TInt appId, const TDesC& actId) const

    {

    return BuildQueryLC(KSelectRow(),appId, actId);

    }

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

/**

 * Format query to select activities for application

 * @param appId - application id

 * @return formated sql query

 */

HBufC* CAfStorage::SelectRowsLC(TInt appId) const

    {

    return BuildQueryLC(KSelectAppRows(), appId, KNullDesC);

    }

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

/**

 * Format query to delete activity

 * @param appId - application id

 * @param actId - activity id

 * @return formated sql query

 */

HBufC* CAfStorage::DeleteRowLC(TInt appId, const TDesC& actId) const

    {

    return BuildQueryLC(KDeleteRow(),appId, actId);

    }

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

/**

 * Format query to delete activities for application

 * @param appId - application id

 * @return formated sql query

 */

HBufC* CAfStorage::DeleteRowsLC(TInt appId) const

    {

    return BuildQueryLC(KDeleteRows(),appId, KNullDesC);

    }

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

/**

 * Format sql query

 * @format - sql format string

 * @param appId - application id

 * @param actId - activity id

 * @return formated sql query

 */

HBufC* CAfStorage::BuildQueryLC(const TDesC& format,

                                      TInt appId,

                                      const TDesC& actId) const

    {

    TBuf<16> appName;

    appName.AppendNum(appId);

    RBuf actName;

    CleanupClosePushL(actName);

    actName.CreateL(actId.Length());

    actName.Copy(actId);

    HBufC* query = HBufC::NewL(format.Length() +

                               appName.Length() +

                               actName.Length() );

    query->Des().AppendFormat(format, &appName, &actName);

    CleanupStack::PopAndDestroy(&actName);

    CleanupStack::PushL(query);

    return query;

    }

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

/**

 * Execute sql query and result serialize into buffer

 * @param dst - destination result buffer

 * @param query - sql activity query

 */

void CAfStorage::ActivitiesL(RPointerArray<CAfEntry>& dst, const TDesC& query, CAfEntry::AccessRights rights, TInt limit, TBool deserializeAllData)

    {

    RDbView view;// Create a view on the database

    CleanupClosePushL(view);

    User::LeaveIfError(view.Prepare(iActDb, TDbQuery(query), view.EReadOnly));

    User::LeaveIfError(view.EvaluateAll());

    ActivitiesL(dst, view, rights, limit, deserializeAllData);

    CleanupStack::PopAndDestroy(&view);

    }

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

/**

 * Return view deserialisd into entries array

 * @param dst - destination result

 * @param query - view

 * @param rights - acess rights

 */

void CAfStorage::ActivitiesL(RPointerArray<CAfEntry>& dst, 

                             RDbView& src, 

                             CAfEntry::AccessRights rights, 

                             TInt limit,

                             TBool deserializeAllData)

    {

    CDbColSet* row = src.ColSetL();

    CleanupStack::PushL(row);

    const TInt flagsOffset(row->ColNo(KFlagsColumnName)),

               applicationOffset(row->ColNo(KApplicationColumnName)),

               activityOffset(row->ColNo(KActivityColumnName)),

               customNameOffset(row->ColNo(KCustomNameColumnName)),

               dataOffset(row->ColNo(KDataColumnName)),

               timestampOffset(row->ColNo(KTimestampColumnName));