/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* which accompanies this distribution, and is available

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*   ?description_line

*

*/

//  INCLUDES

#include "FT_CPosTp114.h"

#include <EPos_CPosLandmarkDatabase.h>

#include <EPos_CPosLmDatabaseManager.h>

#include <connect/sbdefs.h>

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

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

// CPosTp114::GetName

//

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

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

//

void CPosTp114::GetName(TDes& aName) const

    {

    _LIT(KTestName, "Tp114 - Landmark database backup/restore");

    aName = KTestName;

    }

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

// CPosTp114::CloseTest

//

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

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

//

void CPosTp114::CloseTest()

    {

    iLog->Put(_L("CloseTest"));

    }

/**

* Performes the test by connecting to the landmarks server

Test LMREQ152: Landmarks DB backup 

Backup and restore of all Landmarks databases using the system backup shall be possible.

The clients are responsible for release of databases during backup/restore. 

A database directly accessed by a client will not be possible to backup/restore.

*/

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

// CPosTp114::StartL

//

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

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

//

void CPosTp114::StartL()

    {  

    TBool backupTest = FileExistL();

    iLog->Put(_L("DoTestL"));

    CPosTp114BackupListener* backupListener = CPosTp114BackupListener::NewL(iLog);

    CleanupStack::PushL(backupListener);

    if (backupTest)

        {

        iLog->Put(_L("Backup Test"));

        // Backup part

        InitBackupTestL();

        }

    else

        {

        iLog->Put(_L("Restore Test"));

        iLog->Put(_L("Connnect to eposlmserver"));

        // Restore part

        CPosLmDatabaseManager* dbManager = CPosLmDatabaseManager::NewL();

        CleanupStack::PushL(dbManager);

        CDesCArray* dbArray = dbManager->ListDatabasesLC();

        //TInt count = dbArray->Count();

        CleanupStack::PopAndDestroy(dbArray);

        CleanupStack::PopAndDestroy(dbManager);

        }

    // Check landmark server

	_LIT(KPosLandmarksServerName, "*eposlmserver*");

	User::After(5000000); // XXX Add some time here

	TBool result = ETrue;

	TBool alive = ServerAlive(KPosLandmarksServerName);

    if(alive) iLog->Put(_L("ERROR: Server is stil alive"));

    if (backupTest)

        {

        _LIT(KStartBackup, "Now start backup but first press OK");

        TUtfwUserAnswer answer = iUserInfo->ShowDialog(KStartBackup, EUtfwDialogTypeOk, EFalse);

        if(answer == EUtfwUserAnswerOk)

            {

            backupListener->StartCheckingL();

            User::After(10000000); // Wait some time here so that backup is really finished

            }

        }

    else

        {

        _LIT(KStartRestore, "Now start restore, but first press OK");

        TUtfwUserAnswer answer = iUserInfo->ShowDialog(KStartRestore, EUtfwDialogTypeOk, EFalse);

        if(answer == EUtfwUserAnswerOk)

            {

            backupListener->StartCheckingL();

            User::After(10000000); // Wait some time here so that restore is really finished

            }

        }

     if (backupTest)

        {

        // Prepare dbs for restore part

        PrepareForRestoreTestL();

        }

    else

        {

        // Check correct dbs and landmarks restored

        result = CheckDbAfterRestoreL();

        }

    backupListener->Cancel();

    CleanupStack::PopAndDestroy(backupListener);

    if (!result) LogErrorAndLeave(_L("Errors found when restoring"));

	}

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

// CPosTp114::CheckDbAfterRestoreL

//

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

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

//

TBool CPosTp114::CheckDbAfterRestoreL()

    {

    // Check that three landmark dbs exist

    // Check that all dbs contain three landmarks

    _LIT(DB1, "file://C:backupDb1.ldb");

    _LIT(DB2, "file://C:backupDb2.ldb");

    _LIT(DB3, "file://C:backupDb3.ldb");

    iLog->Put(_L("CheckDbAfterRestoreL"));

    CPosLmDatabaseManager* dbManager = CPosLmDatabaseManager::NewL();

    CleanupStack::PushL(dbManager);

    TBool result = ETrue;

    CDesCArray* dbArray = dbManager->ListDatabasesLC();

    TInt count = dbArray->Count();

    //AssertTrueL(count == 3, _L("Wrong nr of dbs after restore"));

    if (count != 3)

        {

        iLog->Put(_L("ERROR: Wrong nr of dbs after restore"));

        result = EFalse;

        }

    TInt pos;

    if (dbArray->Find(DB1, pos) != 0 ||

        dbArray->Find(DB2, pos) != 0 ||

        dbArray->Find(DB3, pos) != 0)

            {

            iLog->Put(_L("Could not find db"));

            result = EFalse;

            }

    CleanupStack::PopAndDestroy(dbArray);

    CleanupStack::PopAndDestroy(dbManager);

    CPosLandmarkDatabase* db = CPosLandmarkDatabase::OpenL(DB1);

    CleanupStack::PushL(db);

    CPosLmItemIterator* iter = db->LandmarkIteratorL();

    CleanupStack::PushL(iter);

    TInt numberOfElements = iter->NumOfItemsL();    

    if (numberOfElements != 3) 

        {

        iLog->Put(_L("Wrong number of landmarks in DB1 "));

        result = EFalse;

        }

    CleanupStack::PopAndDestroy(iter);

    CleanupStack::PopAndDestroy(db);

    return result;

    }

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

// CPosTp114::InitBackupTestL

//

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

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

//

void CPosTp114::InitBackupTestL()

    {

    iLog->Put(_L("InitBackupTestL"));

    // Use this part to create three landmark dbs with some landmarks

    _LIT(DB1, "backupDb1.ldb");

    _LIT(DB2, "backupDb2.ldb");

    _LIT(DB3, "backupDb3.ldb");

    // Firts remove all landmark dbs

    CPosLmDatabaseManager* dbManager = CPosLmDatabaseManager::NewL();

    CleanupStack::PushL(dbManager);

    CDesCArray* dbArray = dbManager->ListDatabasesLC();

    TInt count = dbArray->Count();

    for (TInt i=0;i<count;i++)

        {

        dbManager->DeleteDatabaseL((*dbArray)[i]);

        }

    CleanupStack::PopAndDestroy(dbArray);

    HPosLmDatabaseInfo* dbInfo = HPosLmDatabaseInfo::NewLC(DB1);

	dbManager->CreateDatabaseL(*dbInfo);

	CleanupStack::PopAndDestroy(dbInfo);

	dbInfo = HPosLmDatabaseInfo::NewLC(DB2);

	dbManager->CreateDatabaseL(*dbInfo);

	CleanupStack::PopAndDestroy(dbInfo);

	dbInfo = HPosLmDatabaseInfo::NewLC(DB3);

	dbManager->CreateDatabaseL(*dbInfo);

	CleanupStack::PopAndDestroy(dbInfo);

    // Add landmarks to db1

    CPosLandmarkDatabase* db = CPosLandmarkDatabase::OpenL(DB1);

    CleanupStack::PushL(db);

    if (db->IsInitializingNeeded()) ExecuteAndDeleteLD(db->InitializeL());

	CPosLandmark* lm1 = CPosLandmark::NewLC();

    lm1->SetLandmarkNameL(_L("TP114_Db1_Lm1"));

   	db->AddLandmarkL(*lm1);

   	CleanupStack::PopAndDestroy(lm1);

   	CPosLandmark* lm2 = CPosLandmark::NewLC();

    lm2->SetLandmarkNameL(_L("TP114_Db1_Lm2"));

   	db->AddLandmarkL(*lm2);

   	CleanupStack::PopAndDestroy(lm2);

   	CPosLandmark* lm3 = CPosLandmark::NewLC();

    lm3->SetLandmarkNameL(_L("TP114_Db1_Lm3"));

   	db->AddLandmarkL(*lm3);

   	CleanupStack::PopAndDestroy(lm3);

   	ExecuteAndDeleteLD(db->CompactL());

    CleanupStack::PopAndDestroy(db);

    // Add landmarks to db2

    db = CPosLandmarkDatabase::OpenL(DB2);

    CleanupStack::PushL(db);

    if (db->IsInitializingNeeded()) ExecuteAndDeleteLD(db->InitializeL());

	lm1 = CPosLandmark::NewLC();

    lm1->SetLandmarkNameL(_L("TP114_Db2_Lm1"));

   	db->AddLandmarkL(*lm1);

   	CleanupStack::PopAndDestroy(lm1);

   	lm2 = CPosLandmark::NewLC();

    lm2->SetLandmarkNameL(_L("TP114_Db2_Lm2"));

   	db->AddLandmarkL(*lm2);

   	CleanupStack::PopAndDestroy(lm2);

   	lm3 = CPosLandmark::NewLC();

    lm3->SetLandmarkNameL(_L("TP114_Db2_Lm3"));

   	db->AddLandmarkL(*lm3);

   	CleanupStack::PopAndDestroy(lm3);

   	ExecuteAndDeleteLD(db->CompactL());

    CleanupStack::PopAndDestroy(db);

    // Add landmarks to db3

    db = CPosLandmarkDatabase::OpenL(DB3);

    CleanupStack::PushL(db);

    if (db->IsInitializingNeeded()) ExecuteAndDeleteLD(db->InitializeL());

	lm1 = CPosLandmark::NewLC();

    lm1->SetLandmarkNameL(_L("TP114_Db3_Lm1"));

   	db->AddLandmarkL(*lm1);

   	CleanupStack::PopAndDestroy(lm1);

   	lm2 = CPosLandmark::NewLC();

    lm2->SetLandmarkNameL(_L("TP114_Db3_Lm2"));

   	db->AddLandmarkL(*lm2);

   	CleanupStack::PopAndDestroy(lm2);

   	lm3 = CPosLandmark::NewLC();

    lm3->SetLandmarkNameL(_L("TP114_Db3_Lm3"));

   	db->AddLandmarkL(*lm3);

   	CleanupStack::PopAndDestroy(lm3);

   	ExecuteAndDeleteLD(db->CompactL());

    CleanupStack::PopAndDestroy(db);

	CleanupStack::PopAndDestroy(dbManager);

	iLog->Put(_L("InitBackupTestL Done"));

    }

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

// CPosTp114::PrepareForRestoreTestL

//

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

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

//

void CPosTp114::PrepareForRestoreTestL()

    {

    _LIT(DB1, "backupDb1.ldb");

    _LIT(DB2, "backupDb2.ldb");

    iLog->Put(_L("PrepareForRestoreTestL"));

    // Remove db2 and remove some landmarks from db1

    CPosLmDatabaseManager* dbManager = CPosLmDatabaseManager::NewL();

    CleanupStack::PushL(dbManager);

    //dbManager->DeleteDatabaseL(DB2);

    DeleteFileL(_L("c:\\private\\100012a5\\DBS_101FE978_backupDb2.ldb"));

    CPosLandmarkDatabase* db = CPosLandmarkDatabase::OpenL(DB1);

    CleanupStack::PushL(db);

    CPosLmItemIterator* iter = db->LandmarkIteratorL();

    CleanupStack::PushL(iter);

    RArray<TPosLmItemId> arrayOfIds;

    CleanupClosePushL(arrayOfIds);

    TInt numberOfElements = iter->NumOfItemsL();    

    iter->GetItemIdsL(arrayOfIds, 0, (numberOfElements-1));

    ExecuteAndDeleteLD(db->RemoveLandmarksL(arrayOfIds));

    TBuf<100> buf;

    buf.Format(_L("Removing %d nr of landmarks from db1"), arrayOfIds.Count());

    iLog->Put(buf);

    CleanupStack::PopAndDestroy(&arrayOfIds);

    CleanupStack::PopAndDestroy(iter);

    CleanupStack::PopAndDestroy(db);

	CleanupStack::PopAndDestroy(dbManager);

	iLog->Put(_L("PrepareForRestoreTestL Done"));

    }

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

// CPosTp114::FileExistL

//

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

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

//

TBool CPosTp114::FileExistL()

    {

    _LIT(KIniFile, "c:\\TP114backupTest.ini");

    RFs fileserver;

	RFile file;

	TBool exist = EFalse;

	User::LeaveIfError(fileserver.Connect());

	TInt err = file.Open(fileserver, KIniFile, EFileWrite);

	if (err == KErrNotFound)

		{

		TInt err = file.Create(fileserver, KIniFile, EFileWrite);

		exist = ETrue;

	    file.Close();

	    iLog->Put(_L("File has been created"));

		}

    else

        {

        file.Close();

        TInt err = fileserver.Delete(KIniFile);

        if (err != KErrNone) 

            {

            TBuf<50> buf;

            buf.Format(_L("Could not delete c:\\TP114backupTest.ini, err %d"), err);

            iLog->Put(buf);

            }

        else

            {

            iLog->Put(_L("File has been deleted"));

            }

        exist = EFalse;

        }

	fileserver.Close();

	return exist;

    }

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

// CPosTp114BackupListener

// 

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

//

CPosTp114BackupListener::CPosTp114BackupListener()

    : CActive(EPriorityLow)

    {

    }

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

// CPosTp114BackupListener::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CPosTp114BackupListener::ConstructL(MUtfwLog* aLog)

    {

    TUid categoryUid;

    categoryUid.iUid = KUidSystemCategoryValue;

    User::LeaveIfError(iProperty.Attach(categoryUid,

                                        conn::KUidBackupRestoreKey));

    CActiveScheduler::Add(this);

    iLog = aLog;

    iBackupIsRunning = EFalse;

    // initial subscription and process current property value

    RunL();

    }

// Two-phased constructor

CPosTp114BackupListener* CPosTp114BackupListener::NewL(MUtfwLog* aLog)

    {

    CPosTp114BackupListener* self =

        new (ELeave) CPosTp114BackupListener;

    CleanupStack::PushL(self);

    self->ConstructL(aLog);

    CleanupStack::Pop(self);

    return self;

    }

// Destructor

CPosTp114BackupListener::~CPosTp114BackupListener()

    {

    Cancel();

    iProperty.Close();

    }

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

// CPosTp114BackupListener::RunL

//

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

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

//

void CPosTp114BackupListener::RunL()

    {

   iLog->Put(_L("RunL"));

    // resubscribe before processing new value to prevent missing updates.

    iProperty.Subscribe(iStatus);

    SetActive();

    if (IsBackupRunning())

        {

        iLog->Put(_L("Backup (Restore) is Running...."));

        iBackupIsRunning = ETrue;

        }

    //Check if back to normal (after backup/restore)

    if (!IsBackupRunning() && iBackupIsRunning)

        {

        iLog->Put(_L("After backup/restore"));

        iBackupIsRunning = EFalse;

        CActiveScheduler::Stop();

        }

    }

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

// CPosTp114BackupListener::StartCheckingL

//

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

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

//

void CPosTp114BackupListener::StartCheckingL()

    {

    CActiveScheduler::Start();

    }

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

// CPosTp114BackupListener::IsBackupRunning

//

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

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

//

TBool CPosTp114BackupListener::IsBackupRunning()

    {

    TBool backupIsRunning = EFalse;

    TInt value = 0;

    TInt err = iProperty.Get(value);

    if (err == KErrNone)

        {

        // Use mask to get rid of unwanted info

        TInt partType = conn::KBURPartTypeMask & value;

        // The values EBURUnset or EBURNormal mean

        // that no backup/restore is ongoing.

        if (partType == conn::EBURUnset || partType == conn::EBURNormal)

            {

            backupIsRunning = EFalse;

            }

        else

            {

            backupIsRunning = ETrue;

            }

        }

    else if (err == KErrNotFound)

        {

        // If property is not found, assume that no backup is in progress

        backupIsRunning = EFalse;

        }

    else

        {

        // Some other error occured. In this case,

        // assume that backup is running.

        backupIsRunning = ETrue;

        }