/*

* Copyright (c) 2005-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:  CNssVasDbBuilder is owned by CNssVASDBMgr. It is responsible for creating

*               the context manaher, tag manager, vas db event notifier, and tag select 

*               notifier. This class is a singleton, and is created using the InstanceL(),

*               and deleted using the RemoveInstance() methods. 

*

*/

#include "nssvascvasdbbuilder.h"

#include "rubydebug.h"

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

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

// CNssVASDBBuilder::InstanceL

// This function returns an instance of CNssVASDBBuilder.

// Must be called one to one with RemoveInstance(). 

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

//

CNssVASDBBuilder* CNssVASDBBuilder::InstanceL()

    {

    RUBY_DEBUG_BLOCK( "CNssVASDBBuilder::InstanceL" );

	TThreadLocalStorage* pTls = 0;

	if (Dll::Tls() == 0)

	    {

		CNssVASDBBuilder* instance = CNssVASDBBuilder::NewL();

		CleanupStack::PushL(instance);

		pTls = new (ELeave) TThreadLocalStorage ();

		CleanupStack::Pop(instance);

		pTls->iInstance = instance;

		pTls->iInstanceCount = 0;

		Dll::SetTls (pTls);

	    }

	else

	    {

		pTls = (TThreadLocalStorage *) Dll::Tls();

	    }

	pTls->iInstanceCount++;

	return pTls->iInstance;

    }

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

// CNssVASDBBuilder::RemoveInstance

// This method removes one instance of this class by decrementing

// the number of instances. When the number of instances hit 0,

// the object is deleted. Must be called one to one with InstanceL(). 

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

//

void CNssVASDBBuilder::RemoveInstance() 

    {

    RUBY_DEBUG0( "CNssVASDBBuilder::RemoveInstance" );

	TThreadLocalStorage* pTls = (TThreadLocalStorage *) Dll::Tls();

	if (--pTls->iInstanceCount <= 0)

	    {

		delete pTls->iInstance;

		delete (TThreadLocalStorage *) Dll::Tls();

		Dll::SetTls (0);

	    }

    }

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

// CNssVASDBBuilder::CNssVASDBBuilder

// C++ constructor

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

//

CNssVASDBBuilder::CNssVASDBBuilder()

    {

    }

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

// CNssVASDBBuilder::ConstructL

// EPOC Constructor

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

//

void CNssVASDBBuilder::ConstructL()

    {

	iVasDatabase = CNssVASDatabase::NewL(CActive::EPriorityStandard);

	iContextMgr = CNssContextMgr::NewL(iVasDatabase);

    iTagMgr = CNssTagMgr::NewL(iVasDatabase, iContextMgr);

    iDBTagSelectNotifier = CNssDBTagSelectNotifier::NewL(iVasDatabase);

    //iVASDBEventNotifier = new (ELeave) CNssVASDBEventNotifier(iVasDatabase);

    }

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

// CNssVASDBBuilder::NewL

// 2 phase Construction

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

//

CNssVASDBBuilder* CNssVASDBBuilder::NewL()

    {

    RUBY_DEBUG_BLOCK( "CNssVASDBBuilder::NewL" );

	CNssVASDBBuilder* self = NewLC();

	CleanupStack::Pop(self);

	return (self);

    }

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

// CNssVASDBBuilder::NewLC

// 2 phase Construction

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

//

CNssVASDBBuilder* CNssVASDBBuilder::NewLC()

    {

	CNssVASDBBuilder* self = new(ELeave)CNssVASDBBuilder;

	CleanupStack::PushL(self);

	self->ConstructL();

	return (self);

    }

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

// CNssVASDBBuilder::~CNssVASDBBuilder

// destructor

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

//

CNssVASDBBuilder::~CNssVASDBBuilder()

    {

    RUBY_DEBUG0( "CNssVASDBBuilder::~CNssVASDBBuilder" );

	if(iContextMgr)

	    {

	    delete iContextMgr;

		iContextMgr = NULL;

	    }

	if(iTagMgr)

	    {

		delete iTagMgr;

		iTagMgr = NULL;

	    }

	if(iDBTagSelectNotifier)

	    {

		delete iDBTagSelectNotifier;

		iDBTagSelectNotifier = NULL;

	    }

	if(iVASDBEventNotifier)

	    {

		delete iVASDBEventNotifier;

		iVASDBEventNotifier = NULL;

	    }

	if(iVasDatabase)

	    {

		iVasDatabase->CloseDatabase();

		delete iVasDatabase;

		iVasDatabase = NULL;

	    }

    }

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

// CNssVASDBBuilder::InitializeL

// initialises CNssVASDatabase, by connecting, creating (if not created)

// and opening the datatabase

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

//

void CNssVASDBBuilder::InitializeL()

    {

    RUBY_DEBUG_BLOCK( "CNssVASDBBuilder::InitializeL" );

    if( iInitialized )

    	{

    	RUBY_DEBUG0( "CNssVASDBBuilder::InitializeL Already initialized. Ignoring" );

    	return;

    	}

    TInt err = iVasDatabase->CreateDb();

    if ( err != KErrNone )

        {

        User::Leave( err ); // failed to create database

        }

	// open database 

    err = iVasDatabase->OpenDatabase();

    if ( err != KErrNone && err != KErrDbAlreadyOpen )

        {

        RUBY_DEBUG0( "CNssVASDBBuilder::InitializeL ERROR cannot open VAS DB" );

        User::Leave( err );

        }

    iInitialized = ETrue;

    }

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

// CNssVASDBBuilder::GetContextMgr

// gets the context manager

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

//

CNssContextMgr* CNssVASDBBuilder::GetContextMgr()

    {

	return iContextMgr;

    }

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

// CNssVASDBBuilder::GetTagMgr

// gets the tag manager

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

//

CNssTagMgr* CNssVASDBBuilder::GetTagMgr()

    {

	return  iTagMgr;

    }

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

// CNssVASDBBuilder::GetVASDBEventNotifier

// gets the vas db event notifier

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

//

CNssVASDBEventNotifier* CNssVASDBBuilder::GetVASDBEventNotifier()

    {

	return iVASDBEventNotifier; 

    }

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

// CNssVASDBBuilder::GetTagSelectNotifier

// gets the tag select notifier

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

//

CNssDBTagSelectNotifier* CNssVASDBBuilder::GetTagSelectNotifier()

    {

	return iDBTagSelectNotifier; 

    }

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

// CNssVASDBBuilder::Close

// closes the database

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

//

void CNssVASDBBuilder::Close()

    {

    RUBY_DEBUG0( "CNssVASDBBuilder::Close" );

	if(iVasDatabase)

	    {

		iVasDatabase->CloseDatabase();

	    }

    }