/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:  CLandmarkManageHandlers class implementation

 *

*/

#include <EPos_CPosLandmarkDatabase.h>

#include <EPos_CPosLmCategoryManager.h>

#include <EPos_CPosLandmarkSearch.h>

#include <EPos_TPosLmDatabaseSettings.h>

#include "clandmarkmanagehandlers.h"

//class CLandmarkManageHandlers

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

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

// CLandmarkManageHandlers::NewL()

// Two-phased constructor.

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

//

CLandmarkManageHandlers* CLandmarkManageHandlers::NewL( )

	{

	CLandmarkManageHandlers* self = new (ELeave) CLandmarkManageHandlers();

	return self;

	}

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

// CLandmarkManageHandlers::CLandmarkManageHandlers()

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

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

//

CLandmarkManageHandlers::CLandmarkManageHandlers( )

	{

	}

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

// CLandmarkManageHandlers::~CLandmarkManageHandlers()

// Destructor.

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

//

CLandmarkManageHandlers::~CLandmarkManageHandlers( )

	{

    TInt count = iHandlers.Count();

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

        {

        if (!iHandlers[i]->DecRef())

            {

            delete iHandlers[i];

            }

        }

	iHandlers.Close();

	}

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

// CLandmarkManageHandlers::CloseHandler( CLandmarkHandler* aHandler )

// Closes the passed CLandmarkHandler handle and removes it from the array.

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

//

void CLandmarkManageHandlers::CloseHandler( CLandmarkHandler* aHandler )

	{

	TInt index = iHandlers.Find (aHandler );

	if ( index != KErrNotFound )

		{

        if (!iHandlers[index]->DecRef())

            {

            delete iHandlers[index];

            }

		iHandlers[index] = NULL;

		iHandlers.Remove (index );

		}

	}

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

// CLandmarkManageHandlers::CreateHandlerL(TDesC & aDatabaseUri)

// Creates and Returns the handle of CLandmarkHandler instance.

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

//

CLandmarkHandler* CLandmarkManageHandlers::CreateHandlerL(

		const TDesC& aDatabaseUri )

	{

	//create a database handle and append to the array.

	CLandmarkHandler* handler = CLandmarkHandler::CreateL (aDatabaseUri );

	CleanupStack::PushL (handler );

	iHandlers.AppendL (handler );

	CleanupStack::Pop (handler );

	//if there is no default handler then set default as device default

	if( !iDefaultHandler && aDatabaseUri == KNullDesC )

		{

		iDefaultHandler = handler;

		}

	return handler;

	}

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

// CLandmarkManageHandlers::GetHandlerL(TDesC & aDatabaseUri)

// Returns the handle of CLandmarkHandler instance.

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

//

CLandmarkHandler* CLandmarkManageHandlers::GetHandlerL(const TDesC& aDatabaseUri )

	{

	_LIT(KDriveSeparatorSymbol, ":");

	_LIT(KDefaultDriveLocal, "c");

	_LIT(KProtocolSeparatorLocal, "://");

	_LIT(KLocalProtocolString, "file");

	CLandmarkHandler* handler=  NULL;

	//if aDatabaseUri is KNullDesC then return the default handler

	if ( aDatabaseUri == KNullDesC )

		{

		if ( iDefaultHandler )

			{

			iDefaultHandler->InitL ( );

			}

		handler = iDefaultHandler;

		}

	//else compare the passed URI with the stored handle's URI

	else

		{

		//Simple parsing. Have to implement better parsing

		TBuf<KPosLmDatabaseName> dbName;

		TInt offset = aDatabaseUri.Find (KProtocolSeparatorLocal );

		if ( KErrNotFound == offset )

			{

			dbName.Copy (KLocalProtocolString );

			dbName.Append (KProtocolSeparatorLocal );

			}

		if ( aDatabaseUri.Find (KDriveSeparatorSymbol )<= offset )

			{

			dbName.Append (KDefaultDriveLocal );

			dbName.Append (KDriveSeparatorSymbol );

			}

		//Check for Length < KPosLmDatabaseName

		if ( (aDatabaseUri.Length() + dbName.Length()) > KPosLmDatabaseName )

			{

			User::Leave ( KErrBadName );

			}

		//create the complete db uri

		dbName.Append (aDatabaseUri );

		//normalize to lower

		dbName.LowerCase ( );

		TInt count = iHandlers.Count ( );

		TPtrC dbUri;

		while ( count )

			{

			//Retrieve the handles from end

			handler = iHandlers[--count];

			handler->GetDatabaseUri (dbUri );

			if ( dbUri == dbName )

				{

				handler->InitL ( );

				break;

				}

			//if no handle found then NULL

			handler = NULL;

			}

		}

	return handler;

	}

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

// CLandmarkManageHandlers::SetDefaultHandler(CLandmarkHandler* aHandler)

// Sets the default handler.

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

//

void CLandmarkManageHandlers::SetDefaultHandler( CLandmarkHandler* aHandler )

	{

	iDefaultHandler = aHandler;

	}

//Class CLandmarkHandler

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

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

// CLandmarkHandler::CreateL( TDesC & aDatabaseUri )

// Two-phased constructor.

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

//

CLandmarkHandler* CLandmarkHandler::CreateL( const TDesC& aDatabaseUri )

	{

	CLandmarkHandler* self = new (ELeave) CLandmarkHandler();

	CleanupStack::PushL ( self );

	self->ConstructL (aDatabaseUri );

	CleanupStack::Pop ( self );

	return self;

	}

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

// CLandmarkHandler::ConstructL( TDesC & aDatabaseUri )

// Symbian 2nd phase constructor can leave.

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

//

void CLandmarkHandler::ConstructL( const TDesC& aDatabaseUri )

	{

	//Open default database or the database requested depending on paramater aDatabaseUri

	if ( aDatabaseUri != KNullDesC )

		{

		iLandmarkDatabaseHandle = CPosLandmarkDatabase::OpenL (aDatabaseUri );

		}

	else

		{

		iLandmarkDatabaseHandle = CPosLandmarkDatabase::OpenL ( );

		}

	iDatabaseUri = iLandmarkDatabaseHandle->DatabaseUriLC ( );

	CleanupStack::Pop (iDatabaseUri );

	//Normalize to lower

	iDatabaseUri->Des().LowerCase ( );

	//initialize the database for further opertaions on the database.

	ExecuteAndDeleteLD (iLandmarkDatabaseHandle->InitializeL ( ) );

	//Create other handles with respect to the open database

	iLmCategoryManagerHandle = CPosLmCategoryManager::NewL (*iLandmarkDatabaseHandle );

	iLandmarkSearchHandle = CPosLandmarkSearch::NewL (*iLandmarkDatabaseHandle );

    IncRef();

	}

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

// CLandmarkHandler::CLandmarkHandler()

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

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

//

CLandmarkHandler::CLandmarkHandler( )

	{

	}

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

// CLandmarkHandler::~CLandmarkHandler()

// Destructor.

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

//

CLandmarkHandler::~CLandmarkHandler( )

	{

	delete iLandmarkSearchHandle;

	delete iLmCategoryManagerHandle;

	delete iLandmarkDatabaseHandle;

	delete iDatabaseUri;

	}

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

// CLandmarkHandler::InitL()

// Initialize the databse if required.

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

//

void CLandmarkHandler::InitL( )

	{

	if (iLandmarkDatabaseHandle->IsInitializingNeeded ( ) )

		{

		//Initialize the database for further opertaions on the database.

		ExecuteAndDeleteLD (iLandmarkDatabaseHandle->InitializeL ( ) );

		}

	}

// End of File