/*
* Copyright (c) 2005 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:
* ?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;
}
return backupIsRunning;
}
// -----------------------------------------------------------------------------
// CPosTp114BackupListener::DoCancel
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPosTp114BackupListener::DoCancel()
{
iLog->Put(_L("DoCancel"));
iProperty.Cancel();
}
// End of File