/*

* Copyright (c) 2002-2006 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:  Manages IMSI (DBMS) database 

*

*/

// INCLUDE FILES

#include    "CWPImsiDbHandler.h"

#include    <sysutil.h>

#include    "ProvisioningDebug.h"

// CONSTANTS

_LIT( KSimCardDb,   "wpsimcard.db" );

_LIT( KDbColImsi,   "imsi" ); 

_LIT( KDbSimTable,  "sim" );

_LIT( KDbImsiIndex, "I" );

_LIT( KDbNameDrive, "C:" );

const TInt KEmptyDbSizeEstimate     = 2048; // bytes to write

const TInt KImsiSize                = 16;

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

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

// CWPImsiDbHandler::CWPImsiDbHandler

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CWPImsiDbHandler::CWPImsiDbHandler()

    {

    }

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

// CWPImsiDbHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CWPImsiDbHandler::ConstructL()

    {

    FLOG( _L( "[ProvisioningSC] CWPImsiDbHandler::ConstructL" ) );

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

    // Get process privatepath

    TInt err = iFs.CreatePrivatePath( EDriveC );

    if( err != KErrAlreadyExists )

    	{

    	User::LeaveIfError( err );

    	}

    User::LeaveIfError( iFs.PrivatePath( iDataBasePath ) );

    iDataBasePath.Insert(0, KDbNameDrive );

    iDataBasePath.Append( KSimCardDb );

	// open imsi database

    TInt result( iDb.Open( iFs, iDataBasePath ) );

    FTRACE(RDebug::Print(_L("[ProvisioningSC] CWPImsiDbHandler db open 1 result (%d)"), result));

	if( result == KErrNotFound )

        {

        CreateDatabaseL();

        result = iDb.Open( iFs, iDataBasePath );

        FTRACE(RDebug::Print(_L("[ProvisioningSC] CWPImsiDbHandler db open 2 result (%d)"), result));

        }

    User::LeaveIfError( result );

    if( iDb.IsDamaged() )

        {

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

        }

	User::LeaveIfError( iImsiTable.Open( iDb, KDbSimTable,

		RDbRowSet::TAccess( RDbRowSet::EUpdatable ) ) );

    }

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

// CWPImsiDbHandler::NewL

// Two-phased constructor.

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

//

CWPImsiDbHandler* CWPImsiDbHandler::NewL()

    {

	CWPImsiDbHandler* handler  = CWPImsiDbHandler::NewLC();

    CleanupStack::Pop();

    return handler;

    }

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

// CWPImsiDbHandler::NewLC

// Two-phased constructor.

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

//

CWPImsiDbHandler* CWPImsiDbHandler::NewLC()

    {

    CWPImsiDbHandler* self = new( ELeave ) CWPImsiDbHandler;    

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CWPImsiDbHandler::~CWPImsiDbHandler

// Destructor

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

//

CWPImsiDbHandler::~CWPImsiDbHandler()

    {

	iImsiTable.Close();

	iDb.Close();

    iFs.Close();	

    }

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

// CWPImsiDbHandler::ImsiExistsL

// Check if imsi exists in the database

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

//

TBool CWPImsiDbHandler::ImsiExistsL( const TDesC& aPhoneImsi )

	{

    User::LeaveIfError( iImsiTable.SetIndex( KDbImsiIndex ) );

	TBool result( ETrue );

    if( !iImsiTable.SeekL( TDbSeekKey( aPhoneImsi ) ) )

        {

        result = EFalse;

        }

	return result;

	}

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

// CWPImsiDbHandler::StoreImsiL

// Store new imsi into database

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

//

void CWPImsiDbHandler::StoreImsiL( const TDesC& aPhoneImsi )

	{

	if( aPhoneImsi == KNullDesC )

		{

		User::Leave( KErrBadDescriptor );

		}

	if( SysUtil::FFSSpaceBelowCriticalLevelL( NULL, KImsiSize ) )

		{

		User::Leave( KErrDiskFull );

		}

	CDbColSet* colSet = iImsiTable.ColSetL();

    TInt imsisCol( colSet->ColNo( KDbColImsi ) );

	delete colSet;

	colSet = NULL;

	// create a view on the database

	RDbView view;

	CleanupClosePushL( view ); // 1

	_LIT( KSQLStatement,"select imsi from sim order by imsi" );

	User::LeaveIfError( view.Prepare( iDb,TDbQuery( KSQLStatement,

						                            EDbCompareNormal )));

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

	// begin transaction

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

	CleanupStack::PushL( TCleanupItem( CleanupRollback, &iDb ) ); // 2

	// insert a row

	view.InsertL();	

	CleanupStack::PushL ( TCleanupItem( CleanupCancel, &view ) ); // 3

	view.SetColL( imsisCol, aPhoneImsi );

	view.PutL();

	CleanupStack::Pop(); // cleanupcancel, 3

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

	CleanupStack::Pop(); // cleanuprollback, 2

	CleanupStack::PopAndDestroy(); // view, 1

	return;

	}	

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

// CWPImsiDbHandler::CreateDatabaseL

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

//

void CWPImsiDbHandler::CreateDatabaseL()

	{

	if( SysUtil::FFSSpaceBelowCriticalLevelL( &iFs,	KEmptyDbSizeEstimate ) )

        {

        User::Leave( KErrDiskFull );

        }

    // Get process privatepath

    iDataBasePath.Zero();

    User::LeaveIfError( iFs.PrivatePath( iDataBasePath ) );

    iDataBasePath.Insert(0, KDbNameDrive );

    iDataBasePath.Append( KSimCardDb );

    FLOG( _L( "[ProvisioningSC] CWPImsiDbHandler::CreateDatabaseL priv path" ) );

    FLOG( _L( "[ProvisioningSC] CWPImsiDbHandler::CreateDatabaseL" ) );

    User::LeaveIfError( iDb.Create( iFs, iDataBasePath ) );

    FLOG( _L( "[ProvisioningSC] CWPImsiDbHandler::CreateDatabaseL ok" ) );

	CreateTableL();

	CreateIndexL();

	iDb.Close();

    FLOG( _L( "[ProvisioningSC] CWPImsiDbHandler::CreateDatabaseL done" ) );

	}

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

// CWPImsiDbHandler::CreateTableL

// Create database table

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

//

void CWPImsiDbHandler::CreateTableL()

	{

    CDbColSet* colset = CDbColSet::NewLC(); // 1

    TDbCol idCol( KDbColImsi, EDbColText16 );

    idCol.iAttributes = TDbCol::ENotNull;

	colset->AddL( idCol );

	User::LeaveIfError( iDb.CreateTable( KDbSimTable, *colset ) );  

	CleanupStack::PopAndDestroy(); // colset

    } 

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

// CWPImsiDbHandler::CreateIndexL

// Create database index

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

//

void CWPImsiDbHandler::CreateIndexL()

	{

	CDbKey* key = CDbKey::NewLC(); // 1

	TDbKeyCol imsi( KDbColImsi );

	key->AddL( imsi );

	User::LeaveIfError(  iDb.CreateIndex( KDbImsiIndex, 

							KDbSimTable, *key ) ) ;

    CleanupStack::PopAndDestroy( ); // key

	}

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

// CWPImsiDbHandler::CleanupRollback

// Create database index

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

//

void CWPImsiDbHandler::CleanupRollback( TAny* aItem )

	{

	RDbDatabase* db = static_cast<RDbDatabase*>(aItem);

	db->Rollback();

	}

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

// CWPImsiDbHandler::CleanupCancel

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

//

void CWPImsiDbHandler::CleanupCancel( TAny* aItem )

    {

    RDbTable* table = static_cast<RDbTable*>(aItem);

    table->Cancel();

    }

//  End of File