/*

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

:

    // No implementation required

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

/**

 * Destructor.

 */

CAfStorage::~CAfStorage()

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

/**

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

    path.Append(KDbName);

    path.Insert(0, KDbDrive);

    CleanupStack::PopAndDestroy(&path);

    DeleteNonPersistentActivitiesL();

    RequestCleanup();

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

/**

 * Create database and its structure

 * @param databaseFile - database file path

 */

void CAfStorage::CreateDbL(const TDesC& databaseFile)

                                               databaseFile,

                                               EFileRead|EFileWrite);

    CreateTableL();

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

/**

 * Open database

 * @param databaseFile - database file path

 */

void CAfStorage::OpenDbL(const TDesC& databaseFile)

{

}

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

/**

 * Create database structure

 */

void CAfStorage::CreateTableL()

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

/**

 * Delete non-persistent activities

 */

void CAfStorage::DeleteNonPersistentActivitiesL()

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

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

/**

 * Register new activity

 * @param appId - application id

 * @param actId - activity id

 * @param flags - activity flags

 * @param imgSrc - activity thumbnail source

 * @param privateData - activity private data

 * @param publicData - activity public data

 */

void CAfStorage::AddActivityL(CAfEntry& entry)

    //verify if row already exists

    TInt errNo(KErrNone);

    RDbView view;

    CleanupClosePushL(view);

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

        User::Leave(KErrAlreadyExists);

    CleanupStack::PopAndDestroy(&view);

    //write table

    RDbTable table;

    CleanupClosePushL(table);

    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(KFlagsColumnName), entry.Flags());

    table.PutL();)

        table.Cancel();

        User::Leave(errNo);

    CleanupStack::PopAndDestroy(row);

    CleanupStack::PopAndDestroy(&table);

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

/**

 * Update activity

 * @param entry - activity data

 */

void CAfStorage::UpdateActivityL(CAfEntry& entry)

    RDbView view;

    CleanupClosePushL(view);

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

    view.UpdateL();

    TRAPD(errNo,

    CDbColSet* colSet = view.ColSetL();

    CleanupStack::PushL(colSet);

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

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

    view.PutL();

    CleanupStack::PopAndDestroy(colSet);)

        view.Cancel();

        User::Leave(errNo);

    CleanupStack::PopAndDestroy(&view);

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

/**

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

        // update

        view.UpdateL();

        TRAPD(errNo,

        CDbColSet* colSet = view.ColSetL();

        CleanupStack::PushL(colSet);

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

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

        view.PutL();

        CleanupStack::PopAndDestroy(colSet);)

            view.Cancel();

            User::Leave(errNo);

        }

        // insert

        //write table

        RDbTable table;

        CleanupClosePushL(table);

        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(KFlagsColumnName), entry.Flags());

        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()));

    CleanupStack::PopAndDestroy(query);

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

//

void CAfStorage::DeleteActivitiesL(CAfEntry& entry)

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

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

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

//

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

//

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

/**

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

        User::Leave(KErrNotFound);

    CleanupStack::PopAndDestroy(query);

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

/**

 * Provide initialized file system session

 * @return file system session

 */

RFs& CAfStorage::Fs()

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

/**

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

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